void THD_set_dataset_attributes( THD_3dim_dataset *dset )
{
THD_datablock *blk ;
THD_dataxes *daxes ;
THD_diskptr *dkptr ;
int itemp[IFILL_DIM] , ii ;
float ftemp[FFILL_DIM] ;
int id , nx , ny , nz , nv , nxy , nxyz , ibr , nb ;
int atrank[ATRSIZE_DATASET_RANK] , atdims[ATRSIZE_DATASET_DIMENSIONS] ;
MRI_IMAGE *im ;
int save_order ;
THD_dmat33 tmat ;
THD_dfvec3 tvec ;
mat44 Tc, Tr;
float angle;
char name[666] ; floatvec *fv ;
ENTRY("THD_set_dataset_attributes") ;
/*-- sanity checks --*/
if( ! ISVALID_3DIM_DATASET(dset) ||
! ISVALID_DATABLOCK(dset->dblk) ||
! ISVALID_DISKPTR(dset->dblk->diskptr) ) EXRETURN ;
blk = dset->dblk ; daxes = dset->daxes ; /* always used fixed daxes */
dkptr = blk->diskptr ;
/******/
/****** These attributes used to be set in THD_write_3dim_dataset() *****/
/******/
/*----- write TYPESTRING attribute -----*/
THD_set_string_atr( blk , ATRNAME_TYPESTRING ,
DATASET_typestr[dset->type] ) ;
/*----- write IDCODE attributes -----*/
THD_set_string_atr( blk , ATRNAME_IDSTRING , dset->idcode.str ) ;
THD_set_string_atr( blk , ATRNAME_IDDATE , dset->idcode.date ) ;
if( ! ISZERO_IDCODE(dset->anat_parent_idcode) )
THD_set_string_atr( blk, ATRNAME_IDANATPAR, dset->anat_parent_idcode.str );
else
THD_erase_one_atr ( blk, ATRNAME_IDANATPAR ) ;
if( ! ISZERO_IDCODE(dset->warp_parent_idcode) )
THD_set_string_atr( blk, ATRNAME_IDWARPPAR, dset->warp_parent_idcode.str );
else
THD_erase_one_atr ( blk, ATRNAME_IDWARPPAR ) ;
/*----- write SCENE_TYPE attribute -----*/
itemp[0] = dset->view_type ;
itemp[1] = dset->func_type ;
itemp[2] = dset->type ;
ITFILL(3,ATRSIZE_SCENE_TYPE) ;
THD_set_int_atr( blk , ATRNAME_SCENE_TYPE ,
ATRSIZE_SCENE_TYPE , itemp ) ;
/*----- write data labels -----*/
if( strlen(dset->self_name) == 0 ) DSET_FIX_NAMES(dset) ;
THD_set_string_atr( blk , ATRNAME_LABEL1 , dset->label1 ) ;
THD_set_string_atr( blk , ATRNAME_LABEL2 , dset->label2 ) ;
THD_set_string_atr( blk , ATRNAME_DATANAME , dset->self_name ) ;
if( dset->keywords != NULL )
THD_set_string_atr( blk , ATRNAME_KEYWORDS , dset->keywords ) ;
else
THD_erase_one_atr ( blk , ATRNAME_KEYWORDS ) ;
/*----- write parent names, if they exist -----*/
if( strlen(dset->warp_parent_name) > 0 )
THD_set_string_atr( blk , ATRNAME_WARP_PARENT ,
dset->warp_parent_name ) ;
else
THD_erase_one_atr ( blk , ATRNAME_WARP_PARENT ) ;
if( strlen(dset->anat_parent_name) > 0 )
THD_set_string_atr( blk , ATRNAME_ANATOMY_PARENT ,
dset->anat_parent_name ) ;
else
THD_erase_one_atr ( blk , ATRNAME_ANATOMY_PARENT ) ;
/*----- write axes orientation -----*/
itemp[0] = daxes->xxorient ;
itemp[1] = daxes->yyorient ;
itemp[2] = daxes->zzorient ;
ITFILL(3,ATRSIZE_ORIENT_SPECIFIC) ;
THD_set_int_atr( blk , ATRNAME_ORIENT_SPECIFIC ,
ATRSIZE_ORIENT_SPECIFIC , itemp ) ;
/*----- write axes origin -----*/
ftemp[0] = daxes->xxorg ;
ftemp[1] = daxes->yyorg ;
ftemp[2] = daxes->zzorg ;
FTFILL(3,ATRSIZE_ORIGIN) ;
THD_set_float_atr( blk , ATRNAME_ORIGIN ,
ATRSIZE_ORIGIN , ftemp ) ;
/*----- write axes spacings -----*/
ftemp[0] = daxes->xxdel ;
ftemp[1] = daxes->yydel ;
ftemp[2] = daxes->zzdel ;
FTFILL(3,ATRSIZE_DELTA) ;
THD_set_float_atr( blk , ATRNAME_DELTA ,
ATRSIZE_DELTA , ftemp ) ;
/*-- write matrix for (i,j,k) to DICOM (x,y,z) conversion [15 Dec 2005] --*/
if( !ISVALID_MAT44(daxes->ijk_to_dicom) ) THD_daxes_to_mat44( daxes ) ;
if( ISVALID_MAT44(daxes->ijk_to_dicom) ){
UNLOAD_MAT44(daxes->ijk_to_dicom, ftemp[0],ftemp[1],ftemp[2],ftemp[3],
ftemp[4],ftemp[5],ftemp[6],ftemp[7],
ftemp[8],ftemp[9],ftemp[10],ftemp[11] );
THD_set_float_atr( blk , "IJK_TO_DICOM" , 12 , ftemp ) ;
}
/*-- write matrix for (i,j,k) to DICOM real (x,y,z) conversion [18 May 2007] --*/
/* to store obliquity information */
if(!THD_update_obliquity_status()){ /* maybe update the obliquity unless refitting */
THD_check_oblique_field(dset);
if (ISVALID_MAT44(dset->daxes->ijk_to_dicom_real)){
/* if not oblique already,compute Tc (Cardinal transformation matrix) */
angle = THD_compute_oblique_angle(daxes->ijk_to_dicom_real, 0);
if(angle==0.0){
THD_dicom_card_xform(dset, &tmat, &tvec);
LOAD_MAT44(Tc,
tmat.mat[0][0], tmat.mat[0][1], tmat.mat[0][2], tvec.xyz[0],
tmat.mat[1][0], tmat.mat[1][1], tmat.mat[1][2], tvec.xyz[1],
tmat.mat[2][0], tmat.mat[2][1], tmat.mat[2][2], tvec.xyz[2]);
daxes->ijk_to_dicom_real = Tc;
}
}
}
if( ISVALID_MAT44(daxes->ijk_to_dicom_real) ){
UNLOAD_MAT44(daxes->ijk_to_dicom_real, ftemp[0],ftemp[1],ftemp[2],ftemp[3],
ftemp[4],ftemp[5],ftemp[6],ftemp[7],
ftemp[8],ftemp[9],ftemp[10],ftemp[11] );
THD_set_float_atr( blk , "IJK_TO_DICOM_REAL" , 12 , ftemp ) ;
}
/*----- write markers, if present -----*/
if( dset->markers != NULL ){
for( ii=0 ; ii < MARKS_MAXNUM ; ii++ ){ /* put bad data in */
if( !dset->markers->valid[ii] ) /* invalid markers */
dset->markers->xyz[ii][0] =
dset->markers->xyz[ii][1] =
dset->markers->xyz[ii][2] = FFILL ;
}
THD_set_float_atr( blk , ATRNAME_MARKSXYZ ,
ATRSIZE_MARKSXYZ ,
&(dset->markers->xyz[0][0]) ) ;
THD_set_char_atr( blk , ATRNAME_MARKSLAB ,
ATRSIZE_MARKSLAB ,
&(dset->markers->label[0][0]) ) ;
THD_set_char_atr( blk , ATRNAME_MARKSHELP ,
ATRSIZE_MARKSHELP ,
&(dset->markers->help[0][0]) ) ;
THD_set_int_atr( blk , ATRNAME_MARKSFLAG ,
ATRSIZE_MARKSFLAG ,
&(dset->markers->aflags[0]) ) ;
} else {
THD_erase_one_atr( blk , ATRNAME_MARKSXYZ ) ;
THD_erase_one_atr( blk , ATRNAME_MARKSLAB ) ;
THD_erase_one_atr( blk , ATRNAME_MARKSHELP ) ;
THD_erase_one_atr( blk , ATRNAME_MARKSFLAG ) ;
}
/*----- write warp, if present -----*/
if( dset->warp != NULL ){
int wdata_size = 0 ;
switch( dset->warp->type ){
case WARP_AFFINE_TYPE:{
THD_affine_warp *ww = (THD_affine_warp *) dset->warp ;
itemp[0] = WARP_AFFINE_TYPE ;
itemp[1] = ww->resam_type ;
wdata_size = MAPPING_LINEAR_FSIZE ;
COPY_FROM_STRUCT( ww->warp ,
MAPPING_LINEAR_FSTART ,
float ,
ftemp ,
MAPPING_LINEAR_FSIZE ) ;
}
break ;
case WARP_TALAIRACH_12_TYPE:{
THD_talairach_12_warp *ww =
(THD_talairach_12_warp *) dset->warp ;
int iw , ioff ;
itemp[0] = WARP_TALAIRACH_12_TYPE ;
itemp[1] = ww->resam_type ;
wdata_size = WARP_TALAIRACH_12_SIZE ;
for( iw=0 ; iw < 12 ; iw++ ){
ioff = iw * MAPPING_LINEAR_FSIZE ;
COPY_FROM_STRUCT( ww->warp[iw] ,
MAPPING_LINEAR_FSTART ,
float ,
&(ftemp[ioff]) ,
MAPPING_LINEAR_FSIZE ) ;
}
}
break ;
} /* end of switch on warp type */
ITFILL(2,ATRSIZE_WARP_TYPE) ;
THD_set_int_atr( blk , ATRNAME_WARP_TYPE ,
ATRSIZE_WARP_TYPE , itemp ) ;
THD_set_float_atr( blk , ATRNAME_WARP_DATA ,
wdata_size , ftemp ) ;
} else { /* no warp exists */
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 */
}
Boolean THD_write_atr( THD_datablock *blk )
{
THD_diskptr *dkptr ;
int ia , code , ii ;
ATR_any *atr_any ;
Boolean good = True ;
FILE *header_file ;
ENTRY("THD_write_atr") ;
/*--- sanity checks ---*/
if( ! ISVALID_DATABLOCK(blk) ) RETURN( False );
dkptr = blk->diskptr ;
if( ! ISVALID_DISKPTR(dkptr) || strlen(dkptr->header_name) == 0 ) RETURN( False );
if( DBLK_IS_MINC(blk) ) RETURN( False ); /* 29 Oct 2001 */
if( DBLK_IS_ANALYZE(blk) ) RETURN( False ); /* 27 Aug 2002 */
if( DBLK_IS_NIFTI(blk) ) RETURN( False ); /* 28 Aug 2003 */
if( DBLK_IS_CTFMRI(blk) ) RETURN( False );
if( DBLK_IS_CTFSAM(blk) ) RETURN( False );
if( DBLK_IS_MPEG(blk) ) RETURN( False );
/** 01 Jun 2005: perhaps write in the new NIML format? **/
if( AFNI_yesenv("AFNI_WRITE_NIML") ){
return THD_write_nimlatr( blk ) ;
}
/** Write the old AFNI format **/
header_file = fopen( dkptr->header_name , "w" ) ;
if( header_file == NULL ){
fprintf(stderr,
"*** ERROR: failed to open file %s for attribute writing;\n"
" - Do you have permission to write to this disk?\n"
" - Is the disk full?\n" ,
dkptr->header_name) ;
RETURN( False );
}
for( ia=0 ; ia < blk->natr ; ia++ ){
atr_any = &(blk->atr[ia]) ;
if( ATR_COUNT(atr_any) <= 0 ) continue ;
code = SUCCESS ;
switch( atr_any->type ){
case ATR_FLOAT_TYPE:{
ATR_float * atr_flo = (ATR_float *) atr_any ;
code = fprintf( header_file ,
"\ntype = %s\nname = %s\ncount = %d\n" ,
ATR_typestr[ATR_FLOAT_TYPE] ,
atr_flo->name , atr_flo->nfl ) ;
if( code < 1 ){ code = FAIL ; break ; }
for( ii=0 ; ii < atr_flo->nfl ; ii++ ){
code = fprintf( header_file , " %14.7g" , atr_flo->fl[ii] ) ;
if( ii % 5 == 4 && ii < atr_flo->nfl-1 )
fprintf( header_file , "\n" ) ;
}
code = (code < 1 ) ? FAIL : SUCCESS ;
}
break ;
case ATR_INT_TYPE:{
ATR_int * atr_int = (ATR_int *) atr_any ;
code = fprintf( header_file ,
"\ntype = %s\nname = %s\ncount = %d\n" ,
ATR_typestr[ATR_INT_TYPE] ,
atr_int->name , atr_int->nin ) ;
if( code < 1 ){ code = FAIL ; break ; }
for( ii=0 ; ii < atr_int->nin ; ii++ ){
code = fprintf( header_file , " %d" , atr_int->in[ii] ) ;
if( ii % 5 == 4 && ii < atr_int->nin-1 )
fprintf( header_file , "\n" ) ;
}
code = (code < 1 ) ? FAIL : SUCCESS ;
}
break ;
case ATR_STRING_TYPE:{
ATR_string * atr_str = (ATR_string *) atr_any ;
code = fprintf( header_file ,
"\ntype = %s\nname = %s\ncount = %d\n" ,
ATR_typestr[ATR_STRING_TYPE] ,
atr_str->name , atr_str->nch ) ;
if( code < 1 ){ code = FAIL ; break ; }
THD_zblock( atr_str->nch , atr_str->ch ) ;
fprintf( header_file , "'" ) ;
for( ii=0 ; ii < atr_str->nch ; ii++ ){
code = fprintf( header_file , "%c" , atr_str->ch[ii] ) ;
}
code = (code < 1) ? FAIL : SUCCESS ;
THD_unzblock( atr_str->nch , atr_str->ch ) ;
}
break ;
} /* end of switch on atr type */
good = good && (code != FAIL) ; /* all must not FAIL */
fprintf(header_file,"\n") ;
} /* end of loop over all atr's */
if( good == False ){
fprintf(stderr,
"*** WARNING: error in output to attribute file %s;\n"
" - Is the disk full?\n" ,
dkptr->header_name) ;
}
/*--- close it down ---*/
fclose( header_file ) ;
RETURN( True );
}
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 ;
}
}
