mat44 nifti_dicom2mat(float orient[7], float patientPosition[4], float xyzMM[4]) {
//create NIfTI header based on values from DICOM header
//note orient has 6 values, indexed from 1, patient position and xyzMM have 3 values indexed from 1
mat33 Q, diagVox;
Q.m[0][0] = orient[1]; Q.m[0][1] = orient[2] ; Q.m[0][2] = orient[3] ; // load Q
Q.m[1][0] = orient[4]; Q.m[1][1] = orient[5] ; Q.m[1][2] = orient[6];
//printf("Orient %g %g %g %g %g %g\n",orient[1],orient[2],orient[3],orient[4],orient[5],orient[6] );
/* normalize row 1 */
double val = Q.m[0][0]*Q.m[0][0] + Q.m[0][1]*Q.m[0][1] + Q.m[0][2]*Q.m[0][2] ;
if( val > 0.0l ){
val = 1.0l / sqrt(val) ;
Q.m[0][0] *= (float)val ; Q.m[0][1] *= (float)val ; Q.m[0][2] *= (float)val ;
} else {
Q.m[0][0] = 1.0l ; Q.m[0][1] = 0.0l ; Q.m[0][2] = 0.0l ;
}
/* normalize row 2 */
val = Q.m[1][0]*Q.m[1][0] + Q.m[1][1]*Q.m[1][1] + Q.m[1][2]*Q.m[1][2] ;
if( val > 0.0l ){
val = 1.0l / sqrt(val) ;
Q.m[1][0] *= (float)val ; Q.m[1][1] *= (float)val ; Q.m[1][2] *= (float)val ;
} else {
Q.m[1][0] = 0.0l ; Q.m[1][1] = 1.0l ; Q.m[1][2] = 0.0l ;
}
/* row 3 is the cross product of rows 1 and 2*/
Q.m[2][0] = Q.m[0][1]*Q.m[1][2] - Q.m[0][2]*Q.m[1][1] ; /* cross */
Q.m[2][1] = Q.m[0][2]*Q.m[1][0] - Q.m[0][0]*Q.m[1][2] ; /* product */
Q.m[2][2] = Q.m[0][0]*Q.m[1][1] - Q.m[0][1]*Q.m[1][0] ;
Q = nifti_mat33_transpose(Q);
if (nifti_mat33_determ(Q) < 0.0) {
Q.m[0][2] = -Q.m[0][2];
Q.m[1][2] = -Q.m[1][2];
Q.m[2][2] = -Q.m[2][2];
}
//next scale matrix
LOAD_MAT33(diagVox, xyzMM[1],0.0l,0.0l, 0.0l,xyzMM[2],0.0l, 0.0l,0.0l, xyzMM[3]);
Q = nifti_mat33_mul(Q,diagVox);
mat44 Q44; //4x4 matrix includes translations
LOAD_MAT44(Q44, Q.m[0][0],Q.m[0][1],Q.m[0][2],patientPosition[1],
Q.m[1][0],Q.m[1][1],Q.m[1][2],patientPosition[2],
Q.m[2][0],Q.m[2][1],Q.m[2][2],patientPosition[3]);
return Q44;
}
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 */
THD_3dim_dataset * THD_open_nifti( char *pathname )
{
THD_3dim_dataset *dset=NULL ;
nifti_image *nim ;
int ntt , nbuc , nvals ;
int use_qform = 0 , use_sform = 0, form_code = 0 ;
int statcode = 0 , datum , iview , ibr ;
int scale_data = 0 ; /* flag based on scl_slope and inter 20 Jun 2008 */
int xform_data = 0;
THD_ivec3 orixyz , nxyz ;
THD_fvec3 dxyz , orgxyz ;
THD_mat33 R ;
mat44 ijk_to_dicom44 ;
char *ppp , prefix[THD_MAX_PREFIX] ;
char form_priority = 'S' ; /* 23 Mar 2006 */
static int n_xform_warn=0;
ENTRY("THD_open_nifti") ;
/*-- open input file --*/
{ /* set the nifti_io debug level 8 Apr 2005 [rickr] */
char * ept = my_getenv("AFNI_NIFTI_DEBUG");
if( ept != NULL ) nifti_set_debug_level(atoi(ept));
}
nifti_set_alter_cifti(1) ; /* if CIFTI, shift dims 23 Jul 2015 [rickr] */
nim = nifti_image_read( pathname, 0 ) ;
if( nim == NULL || nim->nifti_type == 0 ) RETURN(NULL) ;
/*-- extract some useful AFNI-ish information from the nim struct --*/
/* we must have at least 2 spatial dimensions */
/* this should be okay 11 Jun 2007 */
/* if( nim->nx < 2 || nim->ny < 2 ) RETURN(NULL) ; */
/* 4th dimension = time; 5th dimension = bucket:
these are mutually exclusive in AFNI at present */
ntt = nim->nt ; nbuc = nim->nu ;
/* nt and nu might be 0 now (see irritating niftilib 1.17 update) */
/* so ensure that ntt and nbuc are positive 02 Mar 2006 [rickr] */
if( ntt <= 0 ) ntt = 1;
if( nbuc <= 0 ) nbuc = 1;
if( nim->nz <= 0 ) nim->nz = 1 ; /* 03 Mar 2006: RWCox */
if( ntt > 1 && nbuc > 1 ){
fprintf(stderr,
"** AFNI can't deal with 5 dimensional NIfTI(%s)\n",
pathname ) ;
RETURN(NULL) ;
}
nvals = MAX(ntt,nbuc) ;
/* collapse higher-dimensional datasets 23 Jul 2015 [rickr] */
/* (this includes CIFTI) */
if( nim->nv > 1 ) nvals *= nim->nv;
if( nim->nw > 1 ) nvals *= nim->nw;
if( ntt > 1 ) ntt = nvals;
else nbuc = nvals;
/* determine type of dataset values:
if we are scaling, or if the data type in the NIfTI file
is something AFNI can't handle, then the result will be floats */
/* do not scale if slope is 0 or if slope is 1 and inter is 0 */
if( !isfinite(nim->scl_slope) || !isfinite(nim->scl_inter) ){
fprintf(stderr,"** bad scl_slope and inter = %f, %f, ignoring...\n",
nim->scl_slope, nim->scl_inter);
} else {
scale_data = nim->scl_slope != 0.0 &&
(nim->scl_slope != 1.0 || nim->scl_inter != 0.0) ;
}
{ char *eee = getenv("AFNI_NIFTI_SCALE") ;
if( eee != NULL && toupper(*eee) == 'N' ) scale_data = 0 ;
}
switch( nim->datatype ){
default:
fprintf(stderr,
"** AFNI can't handle NIFTI datatype=%d (%s) in file %s\n",
nim->datatype, nifti_datatype_string(nim->datatype), pathname );
RETURN(NULL) ;
break ;
case DT_UINT8: datum = scale_data ? MRI_float : MRI_byte ;
xform_data = scale_data;
break ;
case DT_INT16: datum = scale_data ? MRI_float : MRI_short ;
xform_data = scale_data;
break ;
case DT_FLOAT32: datum = MRI_float ; break ;
case DT_COMPLEX64: datum = MRI_complex ; break ;
case DT_RGB24: datum = MRI_rgb ; break ;
case DT_INT8: /* NIfTI-1 data types that AFNI can't handle directly */
case DT_UINT16:
case DT_INT32:
case DT_UINT32:
case DT_FLOAT64: datum = MRI_float ; xform_data = 1 ; break ;
#if 0
case DT_COMPLEX128: /* this case would be too much like real work */
fprintf(stderr,
"** AFNI convert NIFTI_datatype=%d (%s) in file %s to COMPLEX64\n",
nim->datatype, nifti_datatype_string(nim->datatype), pathname );
datum = MRI_complex ;
break ;
#endif
}
if( xform_data && !AFNI_noenv("AFNI_NIFTI_TYPE_WARN")) {
if (!n_xform_warn || AFNI_yesenv("AFNI_NIFTI_TYPE_WARN")) {/* ZSS 04/11 */
fprintf(stderr,
"** AFNI converts NIFTI_datatype=%d (%s) in file %s to FLOAT32\n",
nim->datatype, nifti_datatype_string(nim->datatype), pathname );
if (!AFNI_yesenv("AFNI_NIFTI_TYPE_WARN")) {
fprintf(stderr,
" Warnings of this type will be muted for this session.\n"
" Set AFNI_NIFTI_TYPE_WARN to YES to see them all, NO to see none.\n");
}
}
++n_xform_warn;
}
/* check for statistics code */
if( nim->intent_code >= NIFTI_FIRST_STATCODE &&
nim->intent_code <= NIFTI_LAST_STATCODE ){
if( nim->intent_code > FUNC_PT_TYPE ){
fprintf(stderr,
"** AFNI doesn't understand NIFTI statistic type %d (%s) in file %s\n",
nim->intent_code , nifti_intent_string(nim->intent_code) , pathname ) ;
} else {
statcode = nim->intent_code ;
if( nbuc > 1 ){
fprintf(stderr,
"** AFNI doesn't support NIFTI voxel-dependent statistic parameters"
" in file %s\n" , pathname ) ;
statcode = 0 ;
}
}
}
/* 23 Mar 2006: set qform or sform as having priority -- RWCox */
ppp = my_getenv("NIFTI_FORM_PRIORITY") ;
if( ppp == NULL ) ppp = getenv("AFNI_FORM_PRIORITY") ;
if( ppp == NULL ) ppp = getenv("AFNI_NIFTI_PRIORITY") ;
if( ppp == NULL ) ppp = getenv("AFNI_NIFTI_FORM") ;
if( ppp == NULL ) ppp = getenv("AFNI_NIFTI_FORM_PRIORITY") ;
if( ppp != NULL ){
char fp = toupper(*ppp) ;
if( fp == 'S' || fp == 'Q' ) form_priority = fp ;
else WARNING_message("Illegal NIFTI_FORM_PRIORITY='%s'",ppp) ;
}
/** 24 Mar 2006: check determs of qform and sform, if have both **/
if( nim->qform_code > 0 && nim->sform_code > 0 ){
float qdet , sdet ;
LOAD_MAT(R, nim->qto_xyz.m[0][0] ,
nim->qto_xyz.m[0][1] ,
nim->qto_xyz.m[0][2] ,
nim->qto_xyz.m[1][0] ,
nim->qto_xyz.m[1][1] ,
nim->qto_xyz.m[1][2] ,
nim->qto_xyz.m[2][0] ,
nim->qto_xyz.m[2][1] ,
nim->qto_xyz.m[2][2] ) ; qdet = MAT_DET(R) ;
LOAD_MAT(R, nim->sto_xyz.m[0][0] ,
nim->sto_xyz.m[0][1] ,
nim->sto_xyz.m[0][2] ,
nim->sto_xyz.m[1][0] ,
nim->sto_xyz.m[1][1] ,
nim->sto_xyz.m[1][2] ,
nim->sto_xyz.m[2][0] ,
nim->sto_xyz.m[2][1] ,
nim->sto_xyz.m[2][2] ) ; sdet = MAT_DET(R) ;
if( qdet*sdet < 0.0f )
WARNING_message("NIfTI('%s'): Qform/Sform handedness differ; %c wins!",
pathname , form_priority ) ;
}
/* KRH 07/11/05 -- adding ability to choose spatial transform
from the options of qform, sform, bothform, or noform.
If qform is present, it will be used.
If qform is absent, but sform present, then the sform
will be modified to be an orthogonal rotation and used.
If both qform and sform are absent, then we will have
an error.
Previously assumed qform present. */
/* 23 Mar 2006: use form_priority to choose between them */
if ((nim->qform_code > 0) && (nim->sform_code > 0) ) {
if( form_priority == 'Q' ) { use_qform = 1 ; use_sform = 0 ; }
else { use_qform = 0 ; use_sform = 1 ; }
} else if (nim->qform_code > 0){ use_qform = 1 ; use_sform = 0 ; }
else if (nim->sform_code > 0){ use_qform = 0 ; use_sform = 1 ; }
else {
use_qform = 0 ; use_sform = 0 ;
WARNING_message(
"NO spatial transform (neither qform nor sform), in NIfTI file '%s'" ,
pathname ) ;
}
/** now take NIfTI-1.1 coords and transform to AFNI codes **/
if (use_qform) {
float orgx, orgy, orgz ;
form_code = nim->qform_code;
/* determine orientation from the qto_xyz matrix,
which transforms (i,j,k) voxel indexes to (x,y,z) LPI coordinates */
LOAD_MAT(R, -nim->qto_xyz.m[0][0] , /* negate x and y */
-nim->qto_xyz.m[0][1] , /* coefficients, */
-nim->qto_xyz.m[0][2] , /* since AFNI works */
-nim->qto_xyz.m[1][0] , /* with RAI coords, */
-nim->qto_xyz.m[1][1] , /* but NIFTI uses */
-nim->qto_xyz.m[1][2] , /* LPI coordinates. */
nim->qto_xyz.m[2][0] , /* [Which is my own] */
nim->qto_xyz.m[2][1] , /* [damn fault!!!!!] */
nim->qto_xyz.m[2][2] ) ;
LOAD_MAT44(ijk_to_dicom44,
-nim->qto_xyz.m[0][0] , /* negate x and y */
-nim->qto_xyz.m[0][1] , /* coefficients, */
-nim->qto_xyz.m[0][2] , /* since AFNI works */
-nim->qto_xyz.m[0][3] ,
-nim->qto_xyz.m[1][0] , /* with RAI coords, */
-nim->qto_xyz.m[1][1] , /* but NIFTI uses */
-nim->qto_xyz.m[1][2] , /* LPI coordinates. */
-nim->qto_xyz.m[1][3] ,
nim->qto_xyz.m[2][0] , /* [Which is my own] */
nim->qto_xyz.m[2][1] , /* [damn fault!!!!!] */
nim->qto_xyz.m[2][2] ,
nim->qto_xyz.m[2][3] ) ;
orixyz = THD_matrix_to_orientation( R ) ; /* compute orientation codes */
iview = NIFTI_code_to_view(nim->qform_code);
/* load the offsets and the grid spacings */
if (ORIENT_xyz[orixyz.ijk[0]] == 'z' ) {
orgx = nim->qto_xyz.m[ORIENT_xyzint[orixyz.ijk[0]] - 1][3] ;
} else {
orgx = - nim->qto_xyz.m[ORIENT_xyzint[orixyz.ijk[0]] - 1][3] ;
}
if (ORIENT_xyz[orixyz.ijk[1]] == 'z' ) {
orgy = nim->qto_xyz.m[ORIENT_xyzint[orixyz.ijk[1]] - 1][3] ;
} else {
orgy = - nim->qto_xyz.m[ORIENT_xyzint[orixyz.ijk[1]] - 1][3] ;
}
if (ORIENT_xyz[orixyz.ijk[2]] == 'z' ) {
orgz = nim->qto_xyz.m[ORIENT_xyzint[orixyz.ijk[2]] - 1][3] ;
} else {
orgz = - nim->qto_xyz.m[ORIENT_xyzint[orixyz.ijk[2]] - 1][3] ;
}
LOAD_FVEC3( orgxyz , orgx ,
orgy ,
orgz ) ;
#if 0
LOAD_FVEC3( orgxyz , -nim->qto_xyz.m[0][3] , /* again, negate */
-nim->qto_xyz.m[1][3] , /* x and y coords */
nim->qto_xyz.m[2][3] ) ;
#endif
/* AFNI space units are always mm */
if( nim->xyz_units == NIFTI_UNITS_METER ){
nim->dx *= 1000.0 ; nim->dy *= 1000.0 ; nim->dz *= 1000.0 ;
} else if( nim->xyz_units == NIFTI_UNITS_MICRON ){
nim->dx *= 0.001 ; nim->dy *= 0.001 ; nim->dz *= 0.001 ;
}
LOAD_FVEC3( dxyz , (ORIENT_sign[orixyz.ijk[0]]=='+') ? nim->dx : -nim->dx ,
(ORIENT_sign[orixyz.ijk[1]]=='+') ? nim->dy : -nim->dy ,
(ORIENT_sign[orixyz.ijk[2]]=='+') ? nim->dz : -nim->dz ) ;
} else if (use_sform) {
int orimap[7] = { 6 , 1 , 0 , 2 , 3 , 4 , 5 } ;
int oritmp[3] ;
float dxtmp, dytmp, dztmp ;
float xmax, ymax, zmax ;
float orgx, orgy, orgz ;
float fig_merit, ang_merit ;
form_code = nim->sform_code;
/* convert sform to nifti orientation codes */
/* n2 10 Jul, 2015 [rickr] */
nifti_dmat44_to_orientation(nim->sto_xyz,
&oritmp[0], &oritmp[1], &oritmp[2] ) ;
/* convert nifti orientation codes to AFNI codes and store in vector */
LOAD_IVEC3( orixyz , orimap[oritmp[0]] ,
orimap[oritmp[1]] ,
orimap[oritmp[2]] ) ;
/* assume original view if there's no talairach id present */
iview = NIFTI_code_to_view(nim->sform_code);
/* load the offsets and the grid spacings */
if (ORIENT_xyz[orixyz.ijk[0]] == 'z' ) {
orgx = nim->sto_xyz.m[ORIENT_xyzint[orixyz.ijk[0]] - 1][3] ;
} else {
orgx = - nim->sto_xyz.m[ORIENT_xyzint[orixyz.ijk[0]] - 1][3] ;
}
if (ORIENT_xyz[orixyz.ijk[1]] == 'z' ) {
orgy = nim->sto_xyz.m[ORIENT_xyzint[orixyz.ijk[1]] - 1][3] ;
} else {
orgy = - nim->sto_xyz.m[ORIENT_xyzint[orixyz.ijk[1]] - 1][3] ;
}
if (ORIENT_xyz[orixyz.ijk[2]] == 'z' ) {
orgz = nim->sto_xyz.m[ORIENT_xyzint[orixyz.ijk[2]] - 1][3] ;
} else {
orgz = - nim->sto_xyz.m[ORIENT_xyzint[orixyz.ijk[2]] - 1][3] ;
}
LOAD_FVEC3( orgxyz , orgx ,
orgy ,
orgz ) ;
#if 0
LOAD_FVEC3( orgxyz , -nim->sto_xyz.m[0][3] , /* again, negate */
-nim->sto_xyz.m[1][3] , /* x and y coords */
nim->sto_xyz.m[2][3] ) ;
#endif
#define MAXNUM(a,b) ( (a) > (b) ? (a):(b))
#define MAX3(a,b,c) ( (MAXNUM(a,b)) > (MAXNUM(a,c)) ? (MAXNUM(a,b)):(MAXNUM(a,c)))
#define MINNUM(a,b) ( (a) < (b) ? (a):(b))
#define MIN3(a,b,c) ( (MINNUM(a,b)) < (MINNUM(a,c)) ? (MINNUM(a,b)):(MINNUM(a,c)))
dxtmp = sqrt ( nim->sto_xyz.m[0][0] * nim->sto_xyz.m[0][0] +
nim->sto_xyz.m[1][0] * nim->sto_xyz.m[1][0] +
nim->sto_xyz.m[2][0] * nim->sto_xyz.m[2][0] ) ;
xmax = MAX3(fabs(nim->sto_xyz.m[0][0]),fabs(nim->sto_xyz.m[1][0]),fabs(nim->sto_xyz.m[2][0])) / dxtmp ;
dytmp = sqrt ( nim->sto_xyz.m[0][1] * nim->sto_xyz.m[0][1] +
nim->sto_xyz.m[1][1] * nim->sto_xyz.m[1][1] +
nim->sto_xyz.m[2][1] * nim->sto_xyz.m[2][1] ) ;
ymax = MAX3(fabs(nim->sto_xyz.m[0][1]),fabs(nim->sto_xyz.m[1][1]),fabs(nim->sto_xyz.m[2][1])) / dytmp ;
dztmp = sqrt ( nim->sto_xyz.m[0][2] * nim->sto_xyz.m[0][2] +
nim->sto_xyz.m[1][2] * nim->sto_xyz.m[1][2] +
nim->sto_xyz.m[2][2] * nim->sto_xyz.m[2][2] ) ;
zmax = MAX3(fabs(nim->sto_xyz.m[0][2]),fabs(nim->sto_xyz.m[1][2]),fabs(nim->sto_xyz.m[2][2])) / dztmp ;
fig_merit = MIN3(xmax,ymax,zmax) ;
ang_merit = acos (fig_merit) * 180.0 / 3.141592653 ;
#if 0
if (fabs(ang_merit) > .01) {
WARNING_message (
"qform not present in:\n"
" '%s'\n"
" oblique sform used, and the worst axis is\n"
" %f degrees from plumb.\n"
" If you are performing spatial transformations on this dset, \n"
" or viewing/combining it with volumes of differing obliquity,\n"
" you should consider running: \n"
" 3dWarp -deoblique \n"
" on this and other oblique datasets in the same session.\n"
,pathname, ang_merit ) ;
}
#endif
if( nim->xyz_units == NIFTI_UNITS_METER ){
dxtmp *= 1000.0 ; dytmp *= 1000.0 ; dztmp *= 1000.0 ;
} else if( nim->xyz_units == NIFTI_UNITS_MICRON ){
dxtmp *= 0.001 ; dytmp *= 0.001 ; dztmp *= 0.001 ;
}
LOAD_FVEC3( dxyz , (ORIENT_sign[orixyz.ijk[0]]=='+') ? dxtmp : -dxtmp ,
(ORIENT_sign[orixyz.ijk[1]]=='+') ? dytmp : -dytmp ,
(ORIENT_sign[orixyz.ijk[2]]=='+') ? dztmp : -dztmp ) ;
LOAD_MAT44(ijk_to_dicom44, -nim->sto_xyz.m[0][0] , /* negate x and y */
-nim->sto_xyz.m[0][1] , /* coefficients, */
-nim->sto_xyz.m[0][2] , /* since AFNI works */
-nim->sto_xyz.m[0][3] ,
-nim->sto_xyz.m[1][0] , /* with RAI coords, */
-nim->sto_xyz.m[1][1] , /* but NIFTI uses */
-nim->sto_xyz.m[1][2] , /* LPI coordinates. */
-nim->sto_xyz.m[1][3] ,
nim->sto_xyz.m[2][0] , /* [Which is my own] */
nim->sto_xyz.m[2][1] , /* [damn fault!!!!!] */
nim->sto_xyz.m[2][2] ,
nim->sto_xyz.m[2][3] ) ;
} else { /* NO SPATIAL XFORM. BAD BAD BAD BAD BAD BAD. */
float dxtmp, dytmp, dztmp ;
/* if pixdim data are present, use them in order to set pixel
dimensions. otherwise, set the dimensions to 1 unit. */
dxtmp = ((nim->pixdim[1] > 0) ? nim->pixdim[1] : 1) ;
dytmp = ((nim->pixdim[2] > 0) ? nim->pixdim[2] : 1) ;
dztmp = ((nim->pixdim[3] > 0) ? nim->pixdim[3] : 1) ;
if( nim->xyz_units == NIFTI_UNITS_METER ){
dxtmp *= 1000.0 ; dytmp *= 1000.0 ; dztmp *= 1000.0 ;
} else if( nim->xyz_units == NIFTI_UNITS_MICRON ){
dxtmp *= 0.001 ; dytmp *= 0.001 ; dztmp *= 0.001 ;
}
/* set orientation to LPI by default */
LOAD_IVEC3( orixyz , 1 ,
2 ,
4 ) ;
LOAD_FVEC3( dxyz , (ORIENT_sign[orixyz.ijk[0]]=='+') ? dxtmp : -dxtmp ,
(ORIENT_sign[orixyz.ijk[1]]=='+') ? dytmp : -dytmp ,
(ORIENT_sign[orixyz.ijk[2]]=='+') ? dztmp : -dztmp ) ;
iview = NIFTI_default_view();
/* set origin to 0,0,0 */
LOAD_FVEC3( orgxyz , 0 ,
0 ,
0 ) ;
/* put scaled identity matrix by default */
LOAD_MAT44(ijk_to_dicom44, dxtmp, 0.0, 0.0, 0.0,
0.0, dytmp, 0.0, 0.0,
0.0, 0.0, dztmp, 0.0 );
}
/*-- make an AFNI dataset! --*/
dset = EDIT_empty_copy(NULL) ;
ppp = THD_trailname(pathname,0) ; /* strip directory */
MCW_strncpy( prefix , ppp , THD_MAX_PREFIX ) ; /* to make prefix */
/* You need to set the path too
before, if you loaded ~/tmp/joe.nii the path appeared
to be ./joe.nii, troubling in multiple instances.
ZSS Dec 2011 */
THD_init_diskptr_names( dset->dblk->diskptr ,
THD_filepath(pathname) ,
NULL , prefix ,
dset->view_type , True );
nxyz.ijk[0] = nim->nx ; /* grid dimensions */
nxyz.ijk[1] = nim->ny ;
nxyz.ijk[2] = nim->nz ;
dset->idcode.str[0] = 'N' ; /* overwrite 1st 3 bytes with something special */
dset->idcode.str[1] = 'I' ;
dset->idcode.str[2] = 'I' ;
MCW_hash_idcode( pathname , dset ) ; /* 06 May 2005 */
EDIT_dset_items( dset ,
ADN_prefix , prefix ,
ADN_datum_all , datum ,
ADN_nxyz , nxyz ,
ADN_xyzdel , dxyz ,
ADN_xyzorg , orgxyz ,
ADN_xyzorient , orixyz ,
ADN_malloc_type , DATABLOCK_MEM_MALLOC ,
ADN_view_type , iview ,
ADN_type , (statcode != 0) ? HEAD_FUNC_TYPE
: HEAD_ANAT_TYPE ,
ADN_none ) ;
/* copy transformation matrix to dataset structure */
/* moved after setting grid 4 Apr 2014 [rickr,drg] */
dset->daxes->ijk_to_dicom_real = ijk_to_dicom44;
/* not a time dependent dataset */
if( ntt < 2 ){
EDIT_dset_items( dset ,
ADN_nvals , nbuc ,
ADN_datum_all , datum ,
ADN_func_type , (statcode != 0) ? FUNC_BUCK_TYPE
: ANAT_BUCK_TYPE ,
ADN_none ) ;
} else { /* is a time dependent dataset */
if( nim->time_units == NIFTI_UNITS_MSEC ){
nim->dt *= 0.001 ;
nim->toffset *= 0.001 ;
} else if( nim->time_units == NIFTI_UNITS_USEC ){
nim->dt *= 1.e-6 ;
nim->toffset *= 1.e-6 ;
}
EDIT_dset_items( dset ,
ADN_nvals , ntt ,
ADN_ntt , ntt ,
ADN_datum_all , datum ,
ADN_ttorg , nim->toffset , /* 12 Oct 2007 [rickr] */
ADN_ttdel , nim->dt ,
ADN_ttdur , 0.0 ,
ADN_tunits , UNITS_SEC_TYPE ,
ADN_func_type , (statcode != 0) ? FUNC_FIM_TYPE
: ANAT_EPI_TYPE ,
ADN_none ) ;
/* if present, add stuff about the slice-timing offsets */
if( nim->slice_dim == 3 && /* AFNI can only deal with */
nim->slice_code > 0 && /* slice timing offsets */
nim->slice_duration > 0.0 && /* along the k-axis of */
nim->slice_start >= 0 && /* the dataset volume */
nim->slice_start < nim->nz &&
nim->slice_end > nim->slice_start &&
nim->slice_end < nim->nz ){
float *toff=(float *)calloc(sizeof(float),nim->nz) , tsl ;
int kk ;
if( nim->time_units == NIFTI_UNITS_MSEC ) nim->slice_duration *= 0.001;
else if( nim->time_units == NIFTI_UNITS_USEC ) nim->slice_duration *= 1.e-6;
/* set up slice time offsets in the divers orders */
switch( nim->slice_code ){
case NIFTI_SLICE_SEQ_INC:
tsl = 0.0 ;
for( kk=nim->slice_start ; kk <= nim->slice_end ; kk++ ){
toff[kk] = tsl ; tsl += nim->slice_duration ;
}
break ;
case NIFTI_SLICE_SEQ_DEC:
tsl = 0.0 ;
for( kk=nim->slice_end ; kk >= nim->slice_end ; kk-- ){
toff[kk] = tsl ; tsl += nim->slice_duration ;
}
break ;
case NIFTI_SLICE_ALT_INC:
tsl = 0.0 ;
for( kk=nim->slice_start ; kk <= nim->slice_end ; kk+=2 ){
toff[kk] = tsl ; tsl += nim->slice_duration ;
}
for( kk=nim->slice_start+1 ; kk <= nim->slice_end ; kk+=2 ){
toff[kk] = tsl ; tsl += nim->slice_duration ;
}
break ;
case NIFTI_SLICE_ALT_INC2:
tsl = 0.0 ;
for( kk=nim->slice_start+1 ; kk <= nim->slice_end ; kk+=2 ){
toff[kk] = tsl ; tsl += nim->slice_duration ;
}
for( kk=nim->slice_start ; kk <= nim->slice_end ; kk+=2 ){
toff[kk] = tsl ; tsl += nim->slice_duration ;
}
break ;
case NIFTI_SLICE_ALT_DEC:
tsl = 0.0 ;
for( kk=nim->slice_end ; kk >= nim->slice_start ; kk-=2 ){
toff[kk] = tsl ; tsl += nim->slice_duration ;
}
for( kk=nim->slice_end-1 ; kk >= nim->slice_start ; kk-=2 ){
toff[kk] = tsl ; tsl += nim->slice_duration ;
}
break ;
case NIFTI_SLICE_ALT_DEC2:
tsl = 0.0 ;
for( kk=nim->slice_end-1 ; kk >= nim->slice_start ; kk-=2 ){
toff[kk] = tsl ; tsl += nim->slice_duration ;
}
for( kk=nim->slice_end ; kk >= nim->slice_start ; kk-=2 ){
toff[kk] = tsl ; tsl += nim->slice_duration ;
}
break ;
}
EDIT_dset_items( dset ,
ADN_nsl , nim->nz ,
ADN_zorg_sl , orgxyz.xyz[2] ,
ADN_dz_sl , dxyz.xyz[2] ,
ADN_toff_sl , toff ,
ADN_none ) ;
free(toff) ;
} /* end of slice timing stuff */
} /* end of 3D+time dataset stuff */
/* set atlas space based on NIFTI s/qform code */
NIFTI_code_to_space(form_code,dset);
/* add statistics, if present */
if( statcode != 0 ){
for( ibr=0 ; ibr < nvals ; ibr++ )
EDIT_STATAUX4(dset,ibr,statcode,nim->intent_p1,nim->intent_p2,nim->intent_p3,0) ;
}
/*-- flag to read data from disk using NIFTI functions --*/
dset->dblk->diskptr->storage_mode = STORAGE_BY_NIFTI ;
strcpy( dset->dblk->diskptr->brick_name , pathname ) ;
dset->dblk->diskptr->byte_order = nim->byteorder ;
#if 0
for( ibr=0 ; ibr < nvals ; ibr++ ){ /* make sub-brick labels */
sprintf(prefix,"%s[%d]",tname,ibr) ;
EDIT_BRICK_LABEL( dset , ibr , prefix ) ;
}
#endif
/** 10 May 2005: see if there is an AFNI extension;
if so, load attributes from it and
then edit the dataset appropriately **/
{ int ee ; /* extension index */
/* scan extension list to find the first AFNI extension */
for( ee=0 ; ee < nim->num_ext ; ee++ )
if( nim->ext_list[ee].ecode == NIFTI_ECODE_AFNI &&
nim->ext_list[ee].esize > 32 &&
nim->ext_list[ee].edata != NULL ) break ;
/* if found an AFNI extension ... */
if( ee < nim->num_ext ){
char *buf = nim->ext_list[ee].edata , *rhs , *cpt ;
int nbuf = nim->ext_list[ee].esize - 8 ;
NI_stream ns ;
void *nini ;
NI_group *ngr , *nngr ;
/* if have data, it's long enough, and starts properly, then ... */
if( buf != NULL && nbuf > 32 && strncmp(buf,"<?xml",5)==0 ){
if( buf[nbuf-1] != '\0' ) buf[nbuf-1] = '\0' ; /* for safety */
cpt = strstr(buf,"?>") ; /* find XML prolog close */
if( cpt != NULL ){ /* if found it, then ... */
ns = NI_stream_open( "str:" , "r" ) ;
NI_stream_setbuf( ns , cpt+2 ) ; /* start just after prolog */
nini = NI_read_element(ns,1) ; /* get root element */
NI_stream_close(ns) ;
if( NI_element_type(nini) == NI_GROUP_TYPE ){ /* must be a group */
ngr = (NI_group *)nini ;
if( strcmp(ngr->name,"AFNI_attributes") == 0 ){ /* root is OK */
nngr = ngr ;
} else { /* search in group for proper element */
int nn ; void **nnini ;
nn = NI_search_group_deep( ngr , "AFNI_attributes" , &nnini ) ;
if( nn <= 0 ) nngr = NULL ;
else { nngr = (NI_group *)nnini[0]; NI_free(nnini); }
}
if( NI_element_type(nngr) == NI_GROUP_TYPE ){ /* have good name */
rhs = NI_get_attribute( nngr , "self_idcode" ) ;
if( rhs == NULL )
rhs = NI_get_attribute( nngr , "AFNI_idcode" ) ;
if( rhs != NULL ) /* set dataset ID code from XML attribute */
MCW_strncpy( dset->idcode.str , rhs , MCW_IDSIZE ) ;
rhs = NI_get_attribute( nngr , "NIfTI_nums" ) ; /* check if */
if( rhs != NULL ){ /* dataset dimensions */
char buf[128] ; /* were altered */
sprintf(buf,"%ld,%ld,%ld,%ld,%ld,%d" , /* 12 May 2005 */
nim->nx, nim->ny, nim->nz, nim->nt, nim->nu, nim->datatype );
if( strcmp(buf,rhs) != 0 ){
static int nnn=0 ;
if(nnn==0){fprintf(stderr,"\n"); nnn=1;}
fprintf(stderr,
"** WARNING: NIfTI file %s dimensions altered since "
"AFNI extension was added\n",pathname ) ;
}
}
THD_dblkatr_from_niml( nngr , dset->dblk ); /* load attributes */
THD_datablock_apply_atr( dset ) ; /* apply to dataset struct */
}
NI_free_element( ngr ) ; /* get rid of the root element */
} /* end of if found a group element at the root */
} /* end of if extension data array had an XML prolog close */
} /* end of if had a good extension data array */
} /* end of if had an AFNI extension */
} /* end of processing extensions */
/* return unpopulated dataset */
nifti_image_free(nim) ; RETURN(dset) ;
}
unsigned char * readEcat7(const char *fname, struct TDICOMdata *dcm, struct nifti_1_header *hdr, struct TDCMopts opts, bool isWarnIfNotEcat) {
//data type
#define ECAT7_BYTE 1
#define ECAT7_VAXI2 2
#define ECAT7_VAXI4 3
#define ECAT7_VAXR4 4
#define ECAT7_IEEER4 5
#define ECAT7_SUNI2 6
#define ECAT7_SUNI4 7
//file types
//#define ECAT7_UNKNOWN 0
#define ECAT7_2DSCAN 1
#define ECAT7_IMAGE16 2
#define ECAT7_ATTEN 3
#define ECAT7_2DNORM 4
#define ECAT7_POLARMAP 5
#define ECAT7_VOLUME8 6
#define ECAT7_VOLUME16 7
#define ECAT7_PROJ 8
#define ECAT7_PROJ16 9
#define ECAT7_IMAGE8 10
#define ECAT7_3DSCAN 11
#define ECAT7_3DSCAN8 12
#define ECAT7_3DNORM 13
#define ECAT7_3DSCANFIT 14
PACK( typedef struct {
char magic[14],original_filename[32];
uint16_t sw_version, system_type, file_type;
char serial_number[10];
uint32 scan_start_time;
char isotope_name[8];
Float32 isotope_halflife;
char radiopharmaceutical[32];
Float32 gantry_tilt, gantry_rotation, bed_elevation, intrinsic_tilt;
int16_t wobble_speed, transm_source_type;
Float32 distance_scanned, transaxial_fov;
uint16_t angular_compression, coin_samp_mode, axial_samp_mode;
Float32 ecat_calibration_factor;
uint16_t calibration_unitS, calibration_units_type, compression_code;
char study_type[12], patient_id[16], patient_name[32], patient_sex, patient_dexterity;
Float32 patient_age, patient_height, patient_weight;
uint32 patient_birth_date;
char physician_name[32], operator_name[32], study_description[32];
uint16_t acquisition_type, patient_orientation;
char facility_name[20];
uint16_t num_planes, num_frames, num_gates, num_bed_pos;
Float32 init_bed_position;
Float32 bed_position[15];
Float32 plane_separation;
uint16_t lwr_sctr_thres, lwr_true_thres, upr_true_thres;
char user_process_code[10];
uint16_t acquisition_mode;
Float32 bin_size, branching_fraction;
uint32 dose_start_time;
Float32 dosage, well_counter_corr_factor;
char data_units[32];
uint16_t septa_state;
char fill[12];
}) ecat_main_hdr;
PACK( typedef struct {
int16_t data_type, num_dimensions, x_dimension, y_dimension, z_dimension;
Float32 x_offset, y_offset, z_offset, recon_zoom, scale_factor;
int16_t image_min, image_max;
Float32 x_pixel_size, y_pixel_size, z_pixel_size;
int32_t frame_duration, frame_start_time;
int16_t filter_code;
Float32 x_resolution, y_resolution, z_resolution, num_r_elements, num_angles, z_rotation_angle, decay_corr_fctr;
int32_t processing_code, gate_duration, r_wave_offset, num_accepted_beats;
Float32 filter_cutoff_frequenc, filter_resolution, filter_ramp_slope;
int16_t filter_order;
Float32 filter_scatter_fraction, filter_scatter_slope;
char annotation[40];
Float32 mtx[9], rfilter_cutoff, rfilter_resolution;
int16_t rfilter_code, rfilter_order;
Float32 zfilter_cutoff, zfilter_resolution;
int16_t zfilter_code, zfilter_order;
Float32 mtx_1_4, mtx_2_4, mtx_3_4;
int16_t scatter_type, recon_type, recon_views, fill_cti[87], fill_user[49];
}) ecat_img_hdr;
PACK( typedef struct {
int32_t hdr[4], r[31][4];
}) ecat_list_hdr;
bool swapEndian = false;
size_t n;
FILE *f;
ecat_main_hdr mhdr;
f = fopen(fname, "rb");
if (f)
n = fread(&mhdr, sizeof(mhdr), 1, f);
if(!f || n!=1) {
printMessage("Problem reading ECAT7 file!\n");
fclose(f);
return NULL;
}
if ((mhdr.magic[0] != 'M') || (mhdr.magic[1] != 'A') || (mhdr.magic[2] != 'T')
|| (mhdr.magic[3] != 'R') || (mhdr.magic[4] != 'I') || (mhdr.magic[5] != 'X') ) {
if (isWarnIfNotEcat)
printMessage("Signature not 'MATRIX' (ECAT7): '%s'\n", fname);
fclose(f);
return NULL;
}
swapEndian = mhdr.file_type > 255;
if (swapEndian) {
nifti_swap_2bytes(2, &mhdr.sw_version);
nifti_swap_2bytes(1, &mhdr.file_type);
//nifti_swap_2bytes(1, &mhdr.num_frames);
nifti_swap_4bytes(1, &mhdr.ecat_calibration_factor);
nifti_swap_4bytes(1, &mhdr.isotope_halflife);
nifti_swap_4bytes(2, &mhdr.dosage);
}
if ((mhdr.file_type < ECAT7_2DSCAN) || (mhdr.file_type > ECAT7_3DSCANFIT)) {
printMessage("Unknown ECAT file type %d\n", mhdr.file_type);
fclose(f);
return NULL;
}
//read list matrix
ecat_list_hdr lhdr;
fseek(f, 512, SEEK_SET);
fread(&lhdr, sizeof(lhdr), 1, f);
if (swapEndian) nifti_swap_4bytes(128, &lhdr.hdr[0]);
//offset to first image
int img_StartBytes = lhdr.r[0][1] * 512;
//load image header for first image
fseek(f, img_StartBytes - 512, SEEK_SET); //image header is block immediately before image
ecat_img_hdr ihdr;
fread(&ihdr, sizeof(ihdr), 1, f);
if (swapEndian) {
nifti_swap_2bytes(5, &ihdr.data_type);
nifti_swap_4bytes(5, &ihdr.x_offset);
nifti_swap_2bytes(2, &ihdr.image_min);
nifti_swap_4bytes(5, &ihdr.x_pixel_size);
nifti_swap_2bytes(1, &ihdr.filter_code);
nifti_swap_4bytes(14, &ihdr.x_resolution);
nifti_swap_2bytes(1, &ihdr.filter_order);
nifti_swap_4bytes(2, &ihdr.filter_scatter_fraction);
nifti_swap_4bytes(11, &ihdr.mtx);
nifti_swap_2bytes(2, &ihdr.rfilter_code);
nifti_swap_4bytes(2, &ihdr.zfilter_cutoff);
nifti_swap_2bytes(2, &ihdr.zfilter_code);
nifti_swap_4bytes(3, &ihdr.mtx_1_4);
nifti_swap_2bytes(3, &ihdr.scatter_type);
}
if ((ihdr.data_type != ECAT7_BYTE) && (ihdr.data_type != ECAT7_SUNI2) && (ihdr.data_type != ECAT7_SUNI4)) {
printMessage("Unknown or unsupported ECAT data type %d\n", ihdr.data_type);
fclose(f);
return NULL;
}
int bytesPerVoxel = 2;
if (ihdr.data_type == ECAT7_BYTE) bytesPerVoxel = 1;
if (ihdr.data_type == ECAT7_SUNI4) bytesPerVoxel = 4;
//next: read offsets for each volume: data not saved sequentially (each volume preceded by its own ecat_img_hdr)
int num_vol = 0;
bool isAbort = false;
bool isScaleFactorVaries = false;
#define kMaxVols 16000
size_t * imgOffsets = (size_t *)malloc(sizeof(size_t) * (kMaxVols));
float * imgSlopes = (float *)malloc(sizeof(float) * (kMaxVols));
ecat_img_hdr ihdrN;
while ((lhdr.hdr[0]+lhdr.hdr[3]) == 31) { //while valid list
if (num_vol > 0) { //read the next list
fseek(f, 512 * (lhdr.hdr[1] -1), SEEK_SET);
fread(&lhdr, 512, 1, f);
if (swapEndian) nifti_swap_4bytes(128, &lhdr.hdr[0]);
}
if ((lhdr.hdr[0]+lhdr.hdr[3]) != 31) break; //if valid list
if (lhdr.hdr[3] < 1) break;
for (int k = 0; k < lhdr.hdr[3]; k++) {
//check images' ecat_img_hdr matches first
fseek(f, (lhdr.r[k][1]-1) * 512, SEEK_SET); //image header is block immediately before image
fread(&ihdrN, sizeof(ihdrN), 1, f);
if (swapEndian) {
nifti_swap_2bytes(5, &ihdrN.data_type);
nifti_swap_4bytes(5, &ihdrN.x_offset);
nifti_swap_2bytes(2, &ihdrN.image_min);
nifti_swap_4bytes(5, &ihdrN.x_pixel_size);
nifti_swap_2bytes(1, &ihdrN.filter_code);
nifti_swap_4bytes(14, &ihdrN.x_resolution);
nifti_swap_2bytes(1, &ihdrN.filter_order);
nifti_swap_4bytes(2, &ihdrN.filter_scatter_fraction);
nifti_swap_4bytes(11, &ihdrN.mtx);
nifti_swap_2bytes(2, &ihdrN.rfilter_code);
nifti_swap_4bytes(2, &ihdrN.zfilter_cutoff);
nifti_swap_2bytes(2, &ihdrN.zfilter_code);
nifti_swap_4bytes(3, &ihdrN.mtx_1_4);
nifti_swap_2bytes(3, &ihdrN.scatter_type);
}
if (ihdr.scale_factor != ihdrN.scale_factor)
isScaleFactorVaries = true;
if ((ihdr.data_type != ihdrN.data_type) || (ihdr.x_dimension != ihdrN.x_dimension) || (ihdr.y_dimension != ihdrN.y_dimension) || (ihdr.z_dimension != ihdrN.z_dimension)) {
printError("Error: ECAT volumes have varying image dimensions\n");
isAbort = true;
}
if (num_vol < kMaxVols) {
imgOffsets[num_vol] = lhdr.r[k][1];
imgSlopes[num_vol] = ihdrN.scale_factor;
}
num_vol ++;
}
if ((lhdr.hdr[0] > 0) || (isAbort)) break; //this list contains empty volumes: all lists have been read
} //read all image offsets
//report error reading image offsets
if ((num_vol < 1) || (isAbort) || (num_vol >= kMaxVols)) {
printMessage("Failure to extract ECAT7 images\n");
if (num_vol >= kMaxVols) printMessage("Increase kMaxVols");
fclose(f);
free (imgOffsets);
free(imgSlopes);
return NULL;
}
if ((isScaleFactorVaries) && (bytesPerVoxel != 2)) {
printError("ECAT scale factor varies between volumes (check for updates) '%s'\n", fname);
fclose(f);
free (imgOffsets);
free(imgSlopes);
return NULL;
}
//load image data
unsigned char * img = NULL;
if ((isScaleFactorVaries) && (bytesPerVoxel == 2)) { //we need to convert volumes from 16-bit to 32-bit to preserve scaling factors
int num_vox = ihdr.x_dimension * ihdr.y_dimension * ihdr.z_dimension;
size_t bytesPerVolumeIn = num_vox * bytesPerVoxel; //bytesPerVoxel == 2
unsigned char * imgIn = (unsigned char*)malloc(bytesPerVolumeIn);
int16_t * img16i = (int16_t*) imgIn;
bytesPerVoxel = 4;
size_t bytesPerVolume = num_vox * bytesPerVoxel;
img = (unsigned char*)malloc(bytesPerVolume * num_vol);
float * img32 = (float*) img;
for (int v = 0; v < num_vol; v++) {
fseek(f, imgOffsets[v] * 512, SEEK_SET);
fread( &imgIn[0], 1, bytesPerVolumeIn, f);
if (swapEndian)
nifti_swap_2bytes(num_vox, imgIn);
int volOffset = v * num_vox;
float scale = imgSlopes[v] * mhdr.ecat_calibration_factor;
for (int i = 0; i < num_vox; i++)
img32[i+volOffset] = (img16i[i] * scale);
}
//we have applied the scale factors to the data, so eliminate them
ihdr.scale_factor = 1.0;
mhdr.ecat_calibration_factor = 1.0;
} else { //if isScaleFactorVaries else simple conversion
size_t bytesPerVolume = ihdr.x_dimension * ihdr.y_dimension * ihdr.z_dimension * bytesPerVoxel;
img = (unsigned char*)malloc(bytesPerVolume * num_vol);
for (int v = 0; v < num_vol; v++) {
fseek(f, imgOffsets[v] * 512, SEEK_SET);
size_t sz = fread( &img[v * bytesPerVolume], 1, bytesPerVolume, f);
if (sz != bytesPerVolume) {
free(img);
return NULL;
}
}
if ((swapEndian) && (bytesPerVoxel == 2)) nifti_swap_2bytes(ihdr.x_dimension * ihdr.y_dimension * ihdr.z_dimension * num_vol, img);
if ((swapEndian) && (bytesPerVoxel == 4)) nifti_swap_4bytes(ihdr.x_dimension * ihdr.y_dimension * ihdr.z_dimension * num_vol, img);
}
printWarning("ECAT support VERY experimental (Spatial transforms unknown)\n");
free (imgOffsets);
free(imgSlopes);
fclose(f);
//fill DICOM header
float timeBetweenVolumes = ihdr.frame_duration;
if (num_vol > 1)
timeBetweenVolumes = (float)(ihdrN.frame_start_time- ihdr.frame_start_time)/(float)(num_vol-1);
//copy and clean strings (ECAT can use 0x0D as a string terminator)
strncpy(dcm->patientName, mhdr.patient_name, 32);
strncpy(dcm->patientID, mhdr.patient_id, 16);
strncpy(dcm->seriesDescription, mhdr.study_description, 32);
strncpy(dcm->protocolName, mhdr.study_type, 12);
strncpy(dcm->imageComments, mhdr.isotope_name, 8);
strncpy(dcm->procedureStepDescription, mhdr.radiopharmaceutical, 32);
strClean(dcm->patientName);
strClean(dcm->patientID);
strClean(dcm->seriesDescription);
strClean(dcm->protocolName);
strClean(dcm->imageComments);
strClean(dcm->procedureStepDescription);
dcm->ecat_dosage = mhdr.dosage;
dcm->ecat_isotope_halflife = mhdr.isotope_halflife;
if (opts.isVerbose) {
printMessage("ECAT7 details for '%s'\n", fname);
printMessage(" Software version %d\n", mhdr.sw_version);
printMessage(" System Type %d\n", mhdr.system_type);
printMessage(" Frame duration %dms\n", ihdr.frame_duration);
printMessage(" Time between volumes %gms\n", timeBetweenVolumes );
printMessage(" Patient name '%s'\n", dcm->patientName);
printMessage(" Patient ID '%s'\n", dcm->patientID);
printMessage(" Study description '%s'\n", dcm->seriesDescription);
printMessage(" Study type '%s'\n", dcm->protocolName);
printMessage(" Isotope name '%s'\n", dcm->imageComments);
printMessage(" Isotope halflife %gs\n", mhdr.isotope_halflife);
printMessage(" Radiopharmaceutical '%s'\n", dcm->procedureStepDescription);
printMessage(" Dosage %gbequerels/cc\n", mhdr.dosage);
if (!isScaleFactorVaries) {
printMessage(" Scale factor %12.12g\n", ihdr.scale_factor);
printMessage(" ECAT calibration factor %8.12g\n", mhdr.ecat_calibration_factor);
}
printMessage(" NIfTI scale slope %12.12g\n",ihdr.scale_factor * mhdr.ecat_calibration_factor);
}
dcm->manufacturer = kMANUFACTURER_SIEMENS;
//dcm->manufacturersModelName = itoa(mhdr.system_type);
sprintf(dcm->manufacturersModelName, "%d", mhdr.system_type);
dcm->bitsAllocated = bytesPerVoxel * 8;
if (isScaleFactorVaries) dcm->isFloat = true;
dcm->bitsStored = 15; //ensures 16-bit images saved as INT16 not UINT16
dcm->samplesPerPixel = 1;
dcm->xyzMM[1] = ihdr.x_pixel_size * 10.0; //cm -> mm
dcm->xyzMM[2] = ihdr.y_pixel_size * 10.0; //cm -> mm
dcm->xyzMM[3] = ihdr.z_pixel_size * 10.0; //cm -> mm
dcm->TR = timeBetweenVolumes;
dcm->xyzDim[1] = ihdr.x_dimension;
dcm->xyzDim[2] = ihdr.y_dimension;
dcm->xyzDim[3] = ihdr.z_dimension;
dcm->xyzDim[4] = num_vol;
//create a NIfTI header
headerDcm2Nii(*dcm, hdr, false);
//here we mimic SPM's spatial starting estimate SForm
mat44 m44;
LOAD_MAT44(m44, -hdr->pixdim[1], 0.0f, 0.0f, ((float)dcm->xyzDim[1]-2.0)/2.0*dcm->xyzMM[1],
0.0f, -hdr->pixdim[2], 0.0f, ((float)dcm->xyzDim[2]-2.0)/2.0*dcm->xyzMM[2],
0.0f, 0.0f, -hdr->pixdim[3], ((float)dcm->xyzDim[3]-2.0)/2.0*dcm->xyzMM[3]);
setQSForm(hdr, m44, false);
//make sure image does not include a spatial matrix
bool isMatrix = false;
for (int i = 0; i < 9; i++)
if (ihdr.mtx[i] != 0.0) isMatrix = true;
if (isMatrix)
printWarning("ECAT volume appears to store spatial transformation matrix (please check for updates)\n");
hdr->scl_slope = ihdr.scale_factor * mhdr.ecat_calibration_factor;
if (mhdr.gantry_tilt != 0.0) printMessage("Warning: ECAT gantry tilt not supported %g\n", mhdr.gantry_tilt);
return img;
}
int main (int argc,char *argv[])
{/* Main */
static char FuncName[]={"ConvertSurface"};
int kar, volexists, i, j, Doinv, randseed, Domergesurfs=0, pciref;
float DoR2S, fv[3], *pcxyzref;
double xcen[3], sc[3];
double xform[4][4];
char *if_name = NULL, *of_name = NULL, *if_name2 = NULL,
*of_name2 = NULL, *sv_name = NULL, *vp_name = NULL,
*OF_name = NULL, *OF_name2 = NULL, *tlrc_name = NULL,
*acpc_name=NULL, *xmat_name = NULL, *ifpar_name = NULL,
*ifpar_name2 = NULL;
SUMA_SO_File_Type iType = SUMA_FT_NOT_SPECIFIED,
iparType = SUMA_FT_NOT_SPECIFIED,
oType = SUMA_FT_NOT_SPECIFIED;
SUMA_SO_File_Format iForm = SUMA_FF_NOT_SPECIFIED,
iparForm = SUMA_FF_NOT_SPECIFIED,
oFormat = SUMA_FF_NOT_SPECIFIED;
SUMA_SurfaceObject *SO = NULL, *SOpar = NULL, *SOsurf = NULL;
SUMA_PARSED_NAME *of_name_strip = NULL, *of_name2_strip = NULL;
SUMA_SFname *SF_name = NULL;
void *SO_name = NULL;
char orsurf[6], orcode[6], *PCprojpref=NULL, *NodeDepthpref=NULL;
THD_warp *warp=NULL ;
THD_3dim_dataset *aset=NULL;
SUMA_Boolean brk, Do_tlrc, Do_mni_RAI, Do_mni_LPI, Do_acpc, Docen, Do_flip;
SUMA_Boolean Doxmat, Do_wind, Do_p2s, onemore, Do_native, Do_PolDec;
int Do_PCproj, Do_PCrot, Do_NodeDepth;
SUMA_GENERIC_ARGV_PARSE *ps=NULL;
SUMA_Boolean exists;
SUMA_Boolean LocalHead = NOPE;
SUMA_STANDALONE_INIT;
SUMA_mainENTRY;
/* Allocate space for DO structure */
SUMAg_DOv = SUMA_Alloc_DisplayObject_Struct (SUMA_MAX_DISPLAYABLE_OBJECTS);
ps = SUMA_Parse_IO_Args(argc, argv, "-o;-i;-sv;-ipar;");
kar = 1;
xmat_name = NULL;
xcen[0] = 0.0; xcen[1] = 0.0; xcen[2] = 0.0;
brk = NOPE;
orcode[0] = '\0';
randseed = 1234;
sprintf(orsurf,"RAI");
Docen = NOPE;
Doxmat = NOPE;
Do_tlrc = NOPE;
Do_mni_RAI = NOPE;
Do_mni_LPI = NOPE;
Do_acpc = NOPE;
Do_wind = NOPE;
Do_flip = NOPE;
Do_p2s = NOPE;
Do_native = NOPE;
DoR2S = 0.0;
Do_PolDec = NOPE;
Do_PCproj = NO_PRJ;
Do_PCrot = NO_ROT;
pciref = -1;
pcxyzref = NULL;
PCprojpref = NULL;
NodeDepthpref = NULL;
Do_NodeDepth = 0;
Doinv = 0;
Domergesurfs = 0;
onemore = NOPE;
while (kar < argc) { /* loop accross command ine options */
/*fprintf(stdout, "%s verbose: Parsing command line...\n", FuncName);*/
if (strcmp(argv[kar], "-h") == 0 || strcmp(argv[kar], "-help") == 0) {
usage_SUMA_ConvertSurface(ps, strlen(argv[kar]) > 3 ? 2:1);
exit (0);
}
SUMA_SKIP_COMMON_OPTIONS(brk, kar);
SUMA_TO_LOWER(argv[kar]);
if (!brk && (strcmp(argv[kar], "-seed") == 0)) {
kar ++;
if (kar >= argc) {
fprintf (SUMA_STDERR, "need 1 integer after -seed\n");
exit (1);
}
randseed = atoi(argv[kar]);
brk = YUP;
}
if (!brk && (strcmp(argv[kar], "-xyzscale") == 0)) {
kar ++;
if (kar+2 >= argc) {
fprintf (SUMA_STDERR, "need 3 values after -XYZscale\n");
exit (1);
}
sc[0] = strtod(argv[kar], NULL); kar ++;
sc[1] = strtod(argv[kar], NULL); kar ++;
sc[2] = strtod(argv[kar], NULL);
xmat_name = "Scale";
Doxmat = YUP;
Doinv = 0;
brk = YUP;
}
if (!brk && ( (strcmp(argv[kar], "-xmat_1d") == 0) ||
(strcmp(argv[kar], "-xmat_1D") == 0) ) ) {
kar ++;
if (kar >= argc) {
fprintf (SUMA_STDERR, "need 1 argument after -xmat_1D\n");
exit (1);
}
xmat_name = argv[kar];
Doxmat = YUP;
Doinv = 0;
brk = YUP;
}
if (!brk && ( (strcmp(argv[kar], "-ixmat_1d") == 0) ||
(strcmp(argv[kar], "-ixmat_1D") == 0) ) ) {
kar ++;
if (kar >= argc) {
fprintf (SUMA_STDERR, "need 1 argument after -ixmat_1D\n");
exit (1);
}
xmat_name = argv[kar];
Doxmat = YUP;
Doinv = 1;
brk = YUP;
}
if (!brk && (strcmp(argv[kar], "-polar_decomp") == 0)) {
Do_PolDec = YUP;
brk = YUP;
}
if (!brk && (strcmp(argv[kar], "-merge_surfs") == 0)) {
Domergesurfs = 1;
brk = YUP;
}
if (!brk && (strcmp(argv[kar], "-pc_proj") == 0)) {
kar ++;
if (kar+1 >= argc) {
fprintf (SUMA_STDERR, "need 2 argument after -pc_proj\n");
exit (1);
}
if (!strcmp(argv[kar],"PC0_plane")) Do_PCproj = E1_PLN_PRJ;
else if (!strcmp(argv[kar],"PC1_plane")) Do_PCproj = E2_PLN_PRJ;
else if (!strcmp(argv[kar],"PC2_plane")) Do_PCproj = E3_PLN_PRJ;
else if (!strcmp(argv[kar],"PCZ_plane")) Do_PCproj = EZ_PLN_PRJ;
else if (!strcmp(argv[kar],"PCY_plane")) Do_PCproj = EY_PLN_PRJ;
else if (!strcmp(argv[kar],"PCX_plane")) Do_PCproj = EX_PLN_PRJ;
else if (!strcmp(argv[kar],"PC0_dir")) Do_PCproj = E1_DIR_PRJ;
else if (!strcmp(argv[kar],"PC1_dir")) Do_PCproj = E2_DIR_PRJ;
else if (!strcmp(argv[kar],"PC2_dir")) Do_PCproj = E3_DIR_PRJ;
else if (!strcmp(argv[kar],"PCZ_dir")) Do_PCproj = EZ_DIR_PRJ;
else if (!strcmp(argv[kar],"PCY_dir")) Do_PCproj = EY_DIR_PRJ;
else if (!strcmp(argv[kar],"PCX_dir")) Do_PCproj = EX_DIR_PRJ;
else {
SUMA_S_Err("Bad value of %s for -pca_proj", argv[kar]);
exit(1);
}
++kar;
if (argv[kar][0] == '-') {
SUMA_S_Err("Prefix for -pc_proj should not start with '-'.\n"
"Could it be that %s is another option and \n"
"the prefix was forgtotten?", argv[kar]);
exit(1);
}
PCprojpref = argv[kar];
brk = YUP;
}
if (!brk && (strcmp(argv[kar], "-node_depth") == 0)) {
kar ++;
if (kar >= argc) {
fprintf (SUMA_STDERR, "need a prefix argument after -node_depth\n");
exit (1);
}
Do_NodeDepth = 1;
if (argv[kar][0] == '-') {
SUMA_S_Err("Prefix for -node_depth should not start with '-'.\n"
"Could it be that %s is another option and \n"
"the prefix was forgtotten?", argv[kar]);
exit(1);
}
NodeDepthpref = argv[kar];
brk = YUP;
}
if (!brk && (strcmp(argv[kar], "-make_consistent") == 0)) {
Do_wind = YUP;
brk = YUP;
}
if (!brk && (strcmp(argv[kar], "-flip_orient") == 0)) {
Do_flip = YUP;
brk = YUP;
}
if (!brk && (strcmp(argv[kar], "-xcenter") == 0)) {
kar ++;
if (kar+2>= argc) {
fprintf (SUMA_STDERR, "need 3 arguments after -xcenter\n");
exit (1);
}
xcen[0] = atof(argv[kar]); ++kar;
xcen[1] = atof(argv[kar]); ++kar;
xcen[2] = atof(argv[kar]);
Docen = YUP;
brk = YUP;
}
if (!brk && (strcmp(argv[kar], "-native") == 0)) {
Do_native = YUP;
brk = YUP;
}
if (!brk && (strcmp(argv[kar], "-orient_out") == 0)) {
kar ++;
if (kar>= argc) {
fprintf (SUMA_STDERR, "need 1 argument after -orient_out\n");
exit (1);
}
snprintf(orcode, 4*sizeof(char), "%s", argv[kar]);
if (!SUMA_ok_orstring(orcode)) {
fprintf (SUMA_STDERR, "%s is a bad orientation string\n", orcode);
exit (1);
}
brk = YUP;
}
if (!brk && (strcmp(argv[kar], "-radial_to_sphere") == 0)) {
kar ++;
if (kar >= argc) {
fprintf (SUMA_STDERR, "need 1 argument after -radial_to_sphere\n");
exit (1);
}
DoR2S = atof(argv[kar]);
brk = YUP;
}
if (!brk && (strcmp(argv[kar], "-patch2surf") == 0)) {
Do_p2s = YUP;
brk = YUP;
}
if (!brk && (strcmp(argv[kar], "-xml_ascii") == 0)) {
oFormat = SUMA_XML_ASCII_SURF;
brk = YUP;
}
if (!brk && (strcmp(argv[kar], "-xml_b64") == 0)) {
oFormat = SUMA_XML_B64_SURF;
brk = YUP;
}
if (!brk && (strcmp(argv[kar], "-xml_b64gz") == 0)) {
oFormat = SUMA_XML_B64GZ_SURF;
brk = YUP;
}
if (!brk && (strcmp(argv[kar], "-tlrc") == 0)) {
Do_tlrc = YUP;
brk = YUP;
}
if (!brk && (strcmp(argv[kar], "-acpc") == 0)) {
Do_acpc = YUP;
brk = YUP;
}
if (!brk && (strcmp(argv[kar], "-mni_rai") == 0)) {
Do_mni_RAI = YUP;
brk = YUP;
}
if (!brk && (strcmp(argv[kar], "-mni_lpi") == 0)) {
Do_mni_LPI = YUP;
brk = YUP;
}
if (!brk && !ps->arg_checked[kar]) {
fprintf (SUMA_STDERR,
"Error %s: Option %s not understood. Try -help for usage\n",
FuncName, argv[kar]);
suggest_best_prog_option(argv[0], argv[kar]);
exit (1);
} else {
brk = NOPE;
kar ++;
}
}
if (argc < 3) {
SUMA_S_Err("Too few options");
usage_SUMA_ConvertSurface (ps, 0);
exit (1);
}
/* transfer info from ps structure (backward compat) */
if (ps->o_N_surfnames) {
of_name = ps->o_surfnames[0];
of_name2 = ps->o_surftopo[0];
oType = ps->o_FT[0];
if (oFormat == SUMA_FF_NOT_SPECIFIED) {
oFormat = ps->o_FF[0];
}
}
if (ps->i_N_surfnames) {
if_name = ps->i_surfnames[0];
if_name2 = ps->i_surftopo[0];
iType = ps->i_FT[0];
iForm = ps->i_FF[0];
}
if (ps->ipar_N_surfnames) {
ifpar_name = ps->ipar_surfnames[0];
ifpar_name2 = ps->ipar_surftopo[0];
iparType = ps->ipar_FT[0];
iparForm = ps->ipar_FF[0];
}
if (ps->N_sv) sv_name = ps->sv[0];
if (ps->N_vp) vp_name = ps->vp[0];
/* sanity checks */
if (Do_native && orcode[0] != '\0') {
SUMA_S_Err("Options -native and -orient_out are mutually exclusive");
exit(1);
}
if (Do_mni_LPI && Do_mni_RAI) {
SUMA_S_Err("\nCombining -MNI_lpi and -MNI_rai options.\nNot good.");
exit(1);
}
if (!if_name) {
SUMA_S_Err("input surface not specified.\n");
exit(1);
}
if (!of_name && (Do_PCproj < 0 && !Do_NodeDepth) ) {
SUMA_S_Err("output surface or projection PREFIX not specified.\n");
exit(1);
}
if (iType == SUMA_FT_NOT_SPECIFIED) {
SUMA_S_Err("input type not recognized.\n");
exit(1);
}
if (oType == SUMA_FT_NOT_SPECIFIED && (Do_PCproj < 0 && !Do_NodeDepth) ) {
SUMA_S_Err("output type not recognized.\n");
exit(1);
}
if ( oType != SUMA_GIFTI &&
oFormat >= SUMA_XML_SURF &&
oFormat <= SUMA_XML_B64GZ_SURF &&
(Do_PCproj < 0 && !Do_NodeDepth) ){
SUMA_S_Err("XML output options only valid with -o_gii\n");
exit(1);
}
if (iType == SUMA_SUREFIT) {
if (!if_name2) {
SUMA_S_Err("input SureFit surface incorrectly specified.\n");
exit(1);
}
if (sv_name && !vp_name) {
SUMA_S_Err("VolParent needs the -sv option for SureFit surfaces.");
exit(1);
}
}
if (iType == SUMA_VEC) {
if (!if_name2) {
SUMA_S_Err("Input vec surface incorrectly specified.\n");
exit(1);
}
}
if (( Do_mni_RAI || Do_mni_LPI) && !Do_tlrc) {
SUMA_SL_Warn ( "I hope you know what you're doing.\n"
"The MNI transform should only be applied to a\n"
"Surface in the AFNI tlrc coordinate space.\n");
}
if (Do_acpc && Do_tlrc) {
SUMA_S_Err("You can't do -tlrc and -acpc simultaneously.");
exit(1);
}
if ((Doxmat || Docen) && (Do_acpc || Do_tlrc)) {
SUMA_S_Err("You can't do -tlrc or -acpc with -xmat_1D and -xcenter.\n");
exit(1);
}
if ((!Doxmat && Docen)) {
SUMA_S_Err("You can't use -xcenter without -xmat_1D.\n");
exit(1);
}
if (oType == SUMA_SUREFIT) {
if (!of_name2) {
SUMA_S_Err("output SureFit surface incorrectly specified. \n");
exit(1);
}
}
if (oType == SUMA_VEC) {
if (!of_name2) {
SUMA_S_Err("output vec surface incorrectly specified. \n");
exit(1);
}
}
if ( ps->i_N_surfnames > 1 && !Domergesurfs) {
SUMA_S_Err("Multiple surfaces specified without -merge_surfs option\n"
"Nothing to do for such an input\n");
exit(1);
}
/* test for existence of input files */
if (!SUMA_is_predefined_SO_name(if_name, NULL, NULL, NULL, NULL) &&
!SUMA_filexists(if_name)) {
SUMA_S_Errv("if_name %s not found.\n", if_name);
exit(1);
}
if (if_name2) {
if (!SUMA_filexists(if_name2)) {
SUMA_S_Errv("if_name2 %s not found.\n", if_name2);
exit(1);
}
}
if (ifpar_name2) {
if (!SUMA_filexists(ifpar_name2)) {
SUMA_S_Errv("ifpar_name2 %s not found.\n", ifpar_name2);
exit(1);
}
}
if (ifpar_name) {
if (!SUMA_filexists(ifpar_name)) {
SUMA_S_Errv("ifpar_name %s not found.\n", ifpar_name);
exit(1);
}
}
if (xmat_name) {
if (!strstr(special_xmats,xmat_name) && !SUMA_filexists(xmat_name)) {
SUMA_S_Errv("xmat file %s not found.\n", xmat_name);
exit(1);
}
} else {
if (Do_PolDec) {
SUMA_S_Err("-polar_decomp is useless without -xmat_1D");
exit(1);
}
}
if (sv_name) {
char *head = NULL, view[10];
head = SUMA_AfniPrefix(sv_name, view, NULL, &volexists);
if (!SUMA_AfniExistsView(volexists, view) && !SUMA_filexists(sv_name)) {
fprintf (SUMA_STDERR,
"Error %s: volume %s not found.\n", FuncName, head);
exit(1);
}
if (head) SUMA_free(head); head = NULL;
}
if ((Do_tlrc || Do_acpc) && (!sv_name)) {
fprintf (SUMA_STDERR,
"Error %s: -tlrc must be used with -sv option.\n", FuncName);
exit(1);
}
if (vp_name) {
if (!SUMA_filexists(vp_name)) {
fprintf (SUMA_STDERR,
"Error %s: %s not found.\n", FuncName, vp_name);
exit(1);
}
}
/* check for existence of output files */
if ((Do_PCproj < 0 && !Do_NodeDepth) ) {
if (of_name2) {
SUMA_SFname *SFname;
SO_name = SUMA_2Prefix2SurfaceName (of_name, of_name2, NULL,
vp_name, oType, &exists);
SFname = (SUMA_SFname *)SO_name;
OF_name2 = SUMA_copy_string(SFname->name_topo);
OF_name = SUMA_copy_string(SFname->name_coord);
} else {
SO_name = SUMA_Prefix2SurfaceName (of_name, NULL, vp_name,
oType, &exists);
OF_name = SUMA_copy_string((char *) SO_name);
}
if (exists && !THD_ok_overwrite()) {
if (OF_name2)
fprintf (SUMA_STDERR,
"Error %s: output file(s) %s and/or %s exist already.\n",
FuncName, OF_name, OF_name2);
else fprintf ( SUMA_STDERR,
"Error %s: output file %s exists already.\n",
FuncName, OF_name);
exit(1);
}
}
/* now for the real work */
if (Doxmat) {
MRI_IMAGE *im = NULL;
double *far=NULL;
int nrow, ncol;
if (!strcmp(xmat_name,"RandRigid")) {
SUMA_FillRandXform(xform, randseed, 2);
} else if (!strcmp(xmat_name,"RandAffine")) {
SUMA_FillRandXform(xform, randseed, 3);
} else if (!strcmp(xmat_name,"RandShift")) {
SUMA_FillRandXform(xform, randseed, 1);
} else if (!strcmp(xmat_name,"Scale")) {
SUMA_FillScaleXform(xform, sc);
} else if (!strcmp(xmat_name,"NegXY")) {
SUMA_FillXYnegXform(xform);
} else {
im = mri_read_double_1D (xmat_name);
if (!im) {
SUMA_SLP_Err("Failed to read 1D file");
exit(1);
}
far = MRI_DOUBLE_PTR(im);
nrow = im->nx;
ncol = im->ny;
if (nrow == 1) {
if (ncol != 12) {
SUMA_SL_Err("Mat file must have\n"
"one row of 12 columns.");
mri_free(im); im = NULL; /* done with that baby */
exit(1);
}
i = 0;
while (i < 12) {
xform[i/4][0] = far[i]; ++i;
xform[i/4][1] = far[i]; ++i;
xform[i/4][2] = far[i]; ++i;
xform[i/4][3] = far[i]; ++i;
}
xform[3][0] = 0.0;
xform[3][1] = 0.0;
xform[3][2] = 0.0;
xform[3][3] = 1.0;
} else {
if (ncol < 4 ) {
SUMA_SL_Err("Mat file must have\n"
"at least 4 columns.");
mri_free(im); im = NULL; /* done with that baby */
exit(1);
}
if (nrow < 3 ) {
SUMA_SL_Err("Mat file must have\n"
"at least 3 rows.");
mri_free(im); im = NULL; /* done with that baby */
exit(1);
}
if (ncol > 4) {
SUMA_SL_Warn( "Ignoring entries beyond 4th \n"
"column in transform file.");
}
if (nrow > 3) {
SUMA_SL_Warn( "Ignoring entries beyond 3rd\n"
"row in transform file.\n");
}
for (i=0; i < 3; ++i) {
xform[i][0] = far[i];
xform[i][1] = far[i+nrow];
xform[i][2] = far[i+2*nrow];
xform[i][3] = far[i+3*nrow];
}
xform[3][0] = 0.0;
xform[3][1] = 0.0;
xform[3][2] = 0.0;
xform[3][3] = 1.0;
}
}
if (LocalHead) {
fprintf(SUMA_STDERR,"\n++ ConvertSurface xform:\n");
for (i=0; i < 4; ++i) {
fprintf(SUMA_STDERR," %+.5f\t%+.5f\t%+.5f\t%+.5f\n",
xform[i][0], xform[i][1],
xform[i][2], xform[i][3]);
}
fprintf(SUMA_STDERR,"\n");
}
mri_free(im); im = NULL;
if (Doinv) {
mat44 A, A0;
LOAD_MAT44( A0, \
xform[0][0], xform[0][1], xform[0][2], xform[0][3], \
xform[1][0], xform[1][1], xform[1][2], xform[1][3], \
xform[2][0], xform[2][1], xform[2][2], xform[2][3] );
A = nifti_mat44_inverse(A0);
UNLOAD_MAT44(A, \
xform[0][0], xform[0][1], xform[0][2], xform[0][3], \
xform[1][0], xform[1][1], xform[1][2], xform[1][3], \
xform[2][0], xform[2][1], xform[2][2], xform[2][3] );
}
if (Do_PolDec) {
#ifdef USE_DECOMPOSE_SHOEMAKE
/* a little something to do a polar decomposition on M into M = Q*S*/
{
float det, m[4][4], q[4][4], s[4][4];
char *stmp = SUMA_append_string("QS_",xmat_name);
FILE *fout = fopen(stmp,"w"); SUMA_free(stmp); stmp = NULL;
SUMA_S_Note("FixMe! #include above and if(1) here ...");
det = polar_decomp(M, q,s);
fprintf(fout,"#[M][D]: (D is the shift)\n");
for (i=0;i<3; ++i)
fprintf(fout, "#%.5f %.5f %.5f %.5f\n",
M[i][0], M[i][1], M[i][2], M[i][3]);
fprintf(fout,"#Q:\n");
for (i=0;i<3; ++i)
fprintf(fout, "#%.5f %.5f %.5f %.5f\n",
q[i][0], q[i][1], q[i][2], q[i][3]);
fprintf(fout,"#S:\n");
for (i=0;i<3; ++i)
fprintf(fout, "#%.5f %.5f %.5f %.5f\n",
s[i][0], s[i][1], s[i][2], s[i][3]);
fprintf(fout,"#det: %f\n", det);
fprintf(fout, "#[Q][D]: A close xform to [M][D], "
"without scaling.\n#M = Q*S\n");
for (i=0;i<3; ++i)
fprintf(fout, "%.5f %.5f %.5f %.5f\n",
q[i][0], q[i][1], q[i][2], M[i][3]);
fclose(fout); SUMA_free(stmp); stmp = NULL;
}
/* replace user's xform with orthogonal one: */
fprintf(SUMA_STDOUT,"Replacing matrix:\n");
for (i=0;i<3; ++i)
fprintf( SUMA_STDOUT,
" %.5f %.5f %.5f %.5f\n",
M[i][0], M[i][1], M[i][2], M[i][3]);
fprintf(SUMA_STDOUT," with matrix:\n");
for (i=0;i<3; ++i)
fprintf(SUMA_STDOUT,
" %.5f %.5f %.5f %.5f\n",
q[i][0], q[i][1], q[i][2], M[i][3]);
for (i=0;i<3; ++i) {
M[i][0] = q[i][0]; M[i][1] = q[i][1]; M[i][2] = q[i][2];
}
#else
{/* use the NIFTI polar decomposition function
(same results as above)*/
mat33 Q, A;
for (i=0;i<3;++i) {
A.m[i][0] = xform[i][0];
A.m[i][1] = xform[i][1];
A.m[i][2] = xform[i][2];
}
Q = nifti_mat33_polar( A );
/* replace user's xform with orthogonal one: */
fprintf(SUMA_STDOUT,"Replacing matrix:\n");
for (i=0;i<3; ++i)
fprintf( SUMA_STDOUT,
" %.5f %.5f %.5f %.5f\n",
xform[i][0], xform[i][1],
xform[i][2], xform[i][3]);
fprintf(SUMA_STDOUT," with matrix:\n");
for (i=0;i<3; ++i)
fprintf( SUMA_STDOUT,
" %.5f %.5f %.5f %.5f\n",
Q.m[i][0], Q.m[i][1], Q.m[i][2], xform[i][3]);
for (i=0;i<3; ++i) {
xform[i][0] = Q.m[i][0];
xform[i][1] = Q.m[i][1];
xform[i][2] = Q.m[i][2];
}
}
#endif
}
}
if ( ps->i_N_surfnames == 1) {
/* load that one surface */
SO = SUMA_Load_Surface_Object_Wrapper ( if_name, if_name2, vp_name,
iType, iForm, sv_name, 1);
if (!SO) {
SUMA_S_Err("Failed to read input surface.\n");
exit (1);
}
} else if ( ps->i_N_surfnames > 1 && Domergesurfs) {
SUMA_SurfaceObject **SOar=NULL;
int ii;
SUMA_S_Notev("Merging %d surfaces into 1\n", ps->i_N_surfnames);
SOar = (SUMA_SurfaceObject **)
SUMA_calloc(ps->i_N_surfnames, sizeof(SUMA_SurfaceObject *));
if (ps->N_sv > 1 || ps->N_vp > 1) {
SUMA_S_Errv("Cannot handle multiple (%d) -sv or multiple (%d) -vp\n",
ps->N_sv, ps->N_vp);
exit(1);
}
for (ii = 0; ii<ps->i_N_surfnames; ++ii) {
SOar[ii] = SUMA_Load_Surface_Object_Wrapper(ps->i_surfnames[ii],
ps->i_surftopo[ii],
vp_name,
ps->i_FT[0], ps->i_FF[0],
sv_name, 1);
}
if (!(SO = SUMA_MergeSurfs(SOar, ps->i_N_surfnames))) {
SUMA_S_Err("Failed to merge");
exit(1);
}
for (ii = 0; ii<ps->i_N_surfnames; ++ii) {
SUMA_Free_Surface_Object(SOar[ii]);
SOar[ii]=NULL;
} SUMA_free(SOar); SOar=NULL;
}
if (DoR2S > 0.0000001) {
if (!SUMA_ProjectSurfaceToSphere(SO, NULL , DoR2S , NULL)) {
SUMA_S_Err("Failed to project to surface");
exit(1);
}
}
if (ifpar_name) {
SOpar = SUMA_Load_Surface_Object_Wrapper ( ifpar_name, ifpar_name2,
vp_name, iparType, iparForm, sv_name, 1);
if (!SOpar) {
SUMA_S_Err("Failed to read input parent surface.\n");
exit (1);
}
/* need edge list */
if (!SUMA_SurfaceMetrics_eng (SOpar,"EdgeList", NULL, 0,
SUMAg_CF->DsetList)) {
SUMA_SL_Err("Failed to create edgelist for parent");
exit(1);
}
}
/* if Do_wind */
if (Do_wind) {
fprintf (SUMA_STDOUT,
"Checking and repairing mesh's winding consistency...\n");
/* check the winding, but that won't fix the normals,
you'll have to recalculate those things, if need be ... */
if (!SUMA_SurfaceMetrics_eng (SO, "CheckWind", NULL, 0,
SUMAg_CF->DsetList)) {
SUMA_S_Err("Failed in SUMA_SurfaceMetrics.\n");
exit(1);
}
}
if (Do_flip) {
fprintf (SUMA_STDOUT,
"Flipping triangle winding...\n");
SUMA_FlipSOTriangles(SO);
}
if (Do_tlrc) {
fprintf (SUMA_STDOUT,"Performing talairach transform...\n");
/* form the tlrc version of the surface volume */
tlrc_name = (char *) SUMA_calloc (strlen(SO->VolPar->dirname)+
strlen(SO->VolPar->prefix)+60,
sizeof(char));
sprintf (tlrc_name, "%s%s+tlrc.HEAD",
SO->VolPar->dirname, SO->VolPar->prefix);
if (!SUMA_filexists(tlrc_name)) {
fprintf (SUMA_STDERR,"Error %s: %s not found.\n", FuncName, tlrc_name);
exit(1);
}
/* read the tlrc header */
aset = THD_open_dataset(tlrc_name) ;
if( !ISVALID_DSET(aset) ){
SUMA_S_Err("%s is not a valid data set.\n", tlrc_name) ;
exit(1);
}
if( aset->warp == NULL ){
SUMA_S_Err("tlrc_name does not contain a talairach transform.\n");
exit(1);
}
warp = aset->warp ;
/* now warp the coordinates, one node at a time */
if (!SUMA_AFNI_forward_warp_xyz(warp, SO->NodeList, SO->N_Node)) {
SUMA_S_Err("Failed in SUMA_AFNI_forward_warp_xyz.\n");
exit(1);
}
}
if (Do_acpc) {
fprintf (SUMA_STDOUT,"Performing acpc transform...\n");
/* form the acpc version of the surface volume */
acpc_name = (char *) SUMA_calloc (strlen(SO->VolPar->dirname)+
strlen(SO->VolPar->prefix)+60,
sizeof(char));
sprintf (acpc_name,
"%s%s+acpc.HEAD", SO->VolPar->dirname, SO->VolPar->prefix);
if (!SUMA_filexists(acpc_name)) {
fprintf (SUMA_STDERR,"Error %s: %s not found.\n", FuncName, acpc_name);
exit(1);
}
/* read the acpc header */
aset = THD_open_dataset(acpc_name) ;
if( !ISVALID_DSET(aset) ){
fprintf (SUMA_STDERR,
"Error %s: %s is not a valid data set.\n",
FuncName, acpc_name) ;
exit(1);
}
if( aset->warp == NULL ){
fprintf (SUMA_STDERR,
"Error %s: acpc_name does not contain an acpc transform.\n",
FuncName);
exit(1);
}
warp = aset->warp ;
/* now warp the coordinates, one node at a time */
if (!SUMA_AFNI_forward_warp_xyz(warp, SO->NodeList, SO->N_Node)) {
fprintf (SUMA_STDERR,
"Error %s: Failed in SUMA_AFNI_forward_warp_xyz.\n", FuncName);
exit(1);
}
}
if (Do_mni_RAI) {
fprintf (SUMA_STDOUT,"Performing MNI_RAI transform...\n");
/* apply the mni warp */
if (!SUMA_AFNItlrc_toMNI(SO->NodeList, SO->N_Node, "RAI")) {
fprintf (SUMA_STDERR,
"Error %s: Failed in SUMA_AFNItlrc_toMNI.\n", FuncName);
exit(1);
}
sprintf(orsurf,"RAI");
}
if (Do_mni_LPI) {
fprintf (SUMA_STDOUT,"Performing MNI_LPI transform...\n");
/* apply the mni warp */
if (!SUMA_AFNItlrc_toMNI(SO->NodeList, SO->N_Node, "LPI")) {
fprintf (SUMA_STDERR,
"Error %s: Failed in SUMA_AFNItlrc_toMNI.\n", FuncName);
exit(1);
}
sprintf(orsurf,"LPI");
}
if (Doxmat) {
fprintf (SUMA_STDOUT,"Performing affine transform...\n");
if (LocalHead) {
for (i=0; i<3 ; ++i) {
fprintf (SUMA_STDERR,
"M[%d][:] = %f %f %f %f\n",
i, xform[i][0], xform[i][1], xform[i][2], xform[i][3]);
}
fprintf (SUMA_STDERR,"Cen[:] %f %f %f\n", xcen[0], xcen[1], xcen[2]);
}
if (Docen) {
if (!SUMA_Apply_Coord_xform( SO->NodeList, SO->N_Node, SO->NodeDim,
xform, 0, xcen)) {
SUMA_SL_Err("Failed to xform coordinates"); exit(1);
}
} else {
if (!SUMA_Apply_Coord_xform( SO->NodeList, SO->N_Node, SO->NodeDim,
xform, 0, NULL)) {
SUMA_SL_Err("Failed to xform coordinates"); exit(1);
}
}
SUMA_Blank_AfniSO_Coord_System(SO->aSO);
}
if (orcode[0] != '\0') {
SUMA_LHv("Changing coordinates from %s to %s\n", orsurf, orcode);
if (!SUMA_CoordChange(orsurf, orcode, SO->NodeList, SO->N_Node)) {
SUMA_S_Err("Failed to change coords.");
exit(1);
}
SUMA_Blank_AfniSO_Coord_System(SO->aSO);
}
if (Do_p2s) {
SUMA_SurfaceObject *SOold = SO;
SUMA_LH("Changing patch to surface...");
SO = SUMA_Patch2Surf(SOold->NodeList, SOold->N_Node,
SO->FaceSetList, SO->N_FaceSet, 3);
if (!SO) {
SUMA_S_Err("Failed to change patch to surface.");
exit(1);
}
/* get rid of old surface object */
SUMA_Free_Surface_Object(SOold);
}
if (Do_native) {
if (!SUMA_Delign_to_VolPar (SO, NULL)) {
SUMA_S_Err("Failed to transform coordinates to native space");
exit(1);
}
}
if (Do_NodeDepth) {
float *dpth=NULL, mx=0.0;
SUMA_PC_XYZ_PROJ *pcp=NULL;
if (SUMA_NodeDepth(SO->NodeList, SO->N_Node, E1_DIR_PRJ, &dpth,
0.0, NULL, &mx, &pcp) < 0) {
SUMA_S_Err("Failed to compute node depth");
exit(1);
} else {
if (!SUMA_WriteNodeDepth(NodeDepthpref,pcp,dpth, mx)) {
SUMA_S_Err("Failed to write node depth");
exit(1);
}
}
SUMA_ifree(dpth);
pcp = SUMA_Free_PC_XYZ_Proj(pcp);
}
if (Do_PCproj > NO_PRJ) {
SUMA_PC_XYZ_PROJ *pcp=NULL;
pciref = 0; pcxyzref = NULL;
if (!(pcp = SUMA_Project_Coords_PCA(SO->NodeList, SO->N_Node,
pciref, pcxyzref, Do_PCproj, Do_PCrot, 1))) {
SUMA_S_Err("Failed to project");
exit(1);
} else {
if (!SUMA_Write_PC_XYZ_Proj(pcp, PCprojpref)) {
SUMA_S_Err("Failed to write out projections");
exit(1);
} else {
pcp = SUMA_Free_PC_XYZ_Proj(pcp);
}
exit(0);
}
}
/* write the surface object */
if (SO_name) {
if (LocalHead) SUMA_Print_Surface_Object (SO, stderr);
fprintf (SUMA_STDOUT,"Writing surface...\n");
if (!(SUMA_Save_Surface_Object ( SO_name,
SO, oType, oFormat, SOpar))) {
fprintf (SUMA_STDERR,
"Error %s: Failed to write surface object.\n",
FuncName);
exit (1);
}
}
if (of_name_strip) of_name_strip = SUMA_Free_Parsed_Name (of_name_strip);
if (of_name2_strip) of_name2_strip = SUMA_Free_Parsed_Name (of_name2_strip);
if (OF_name) SUMA_free(OF_name);
if (OF_name2) SUMA_free(OF_name2);
if (SF_name) SUMA_free(SF_name);
if (SO_name) SUMA_free(SO_name);
if (SO) SUMA_Free_Surface_Object(SO);
if (SOpar) SUMA_Free_Surface_Object(SOpar);
if (ps) SUMA_FreeGenericArgParse(ps); ps = NULL;
return (0);
}