char *regio_read_subject(const char *regfile)
{
float inplaneres, betplaneres, intensity;
int float2int;
MATRIX *R;
char *subject;
regio_read_register(regfile, &subject, &inplaneres,&betplaneres,
&intensity, &R,&float2int);
MatrixFree(&R);
return(subject);
}
/*
MATRIX *regio_read_registermat(char *regfile)
Just reads in the matrix and leaves the rest of the
crap in the file.
*/
MATRIX *regio_read_registermat(char *regfile)
{
char *subject;
float inplaneres, betplaneres, intensity;
int float2int, err;
MATRIX *R;
err = regio_read_register(regfile, &subject, &inplaneres,
&betplaneres, &intensity, &R, &float2int);
if(err) return(NULL);
free(subject);
return(R);
}
MATRIX *
regio_read_surfacexform_from_register_dat(char *fname, MRI_SURFACE *mris,
MRI *mri, char **subject)
{
MATRIX *Ta, *Sa, *invT, *A, *R, *S, *invSa, *T, *m1, *m2, *B ;
float pres, bres, intensity ;
int float2int ;
MRI *mri_surf = MRIallocHeader(mris->vg.width, mris->vg.height,
mris->vg.depth, MRI_UCHAR,1) ;
if (regio_read_register(fname, subject, &pres, &bres, &intensity,&B,&float2int) != 0)
ErrorReturn(NULL, (ERROR_NOFILE,
"regio_read_surfacexform_from_register_dat(%s) failed",
fname)) ;
MRIcopyVolGeomToMRI(mri_surf, &mris->vg) ;
T = MRIxfmCRS2XYZtkreg(mri) ;
S = MRIgetVoxelToRasXform(mri) ;
Ta = MRIxfmCRS2XYZtkreg(mri_surf);
Sa = MRIgetVoxelToRasXform(mri_surf);
invSa = MatrixInverse(Sa, NULL) ;
invT = MatrixInverse(T,NULL);
A = MatrixMultiply(S,invT, NULL);
m1 = MatrixMultiply(A, B, NULL) ;
m2 = MatrixMultiply(invSa, m1, NULL) ;
R = MatrixMultiply(Ta, m2, NULL) ;
MatrixFree(&A) ; MatrixFree(&Ta) ; MatrixFree(&Sa) ; MatrixFree(&invT) ;
MatrixFree(&B) ; MatrixFree(&m1) ; MatrixFree(&m2) ; MatrixFree(&S) ;
MatrixFree(&invSa);
MatrixFree(&T) ;
MRIfree(&mri_surf) ;
return(R) ;
}
/*---------------------------------------------------------*/
int main(int argc, char **argv) {
int n,err, f, nhits, r,c,s;
float ipr, bpr, intensity;
float *framepower=NULL, val;
LTA *lta;
int nargs;
//int endian,roitype;
/* rkt: check for and handle version tag */
nargs = handle_version_option (argc, argv, "$Id: mri_vol2roi.c,v 1.32 2011/03/02 00:04:25 nicks Exp $", "$Name: stable5 $");
if (nargs && argc - nargs == 1)
exit (0);
argc -= nargs;
Progname = argv[0] ;
argc --;
argv++;
ErrorInit(NULL, NULL, NULL) ;
DiagInit(NULL, NULL, NULL) ;
if (argc == 0) usage_exit();
parse_commandline(argc, argv);
check_options();
printf("--------------------------------------------------------\n");
getcwd(tmpstr,2000);
printf("%s\n",tmpstr);
printf("%s\n",Progname);
for (n=0;n<argc;n++) printf(" %s",argv[n]);
printf("\n");
printf("version %s\n",vcid);
printf("--------------------------------------------------------\n");
dump_options(stdout);
/* --------- load in the (possibly 4-D) source volume --------------*/
printf("Loading volume %s ...",srcvolid);
mSrcVol = MRIread(srcvolid);
if(mSrcVol == NULL) exit(1);
printf("done\n");
/* Dsrc: read the source registration file */
if (srcregfile != NULL) {
err = regio_read_register(srcregfile, &srcsubject, &ipr, &bpr,
&intensity, &Dsrc, &float2int_src);
if (err) exit(1);
printf("srcreg Dsrc -------------\n");
MatrixPrint(stdout,Dsrc);
printf("----------------------------------\n");
} else Dsrc = NULL;
/* Wsrc: Get the source warping Transform */
Wsrc = NULL;
/* Fsrc: Get the source FOV registration matrix */
Fsrc = NULL;
/* Qsrc: Compute the quantization matrix for src volume */
Qsrc = FOVQuantMatrix(mSrcVol->width, mSrcVol->height, mSrcVol->depth,
mSrcVol->xsize, mSrcVol->ysize, mSrcVol->zsize);
printf("ras2vox src (tkreg) Qsrc -------------\n");
MatrixPrint(stdout,Qsrc);
printf("----------------------------------\n");
/* ----------- load in the label ----------------- */
if (labelfile != NULL) {
Label = LabelReadFile(labelfile);
if (Label == NULL) exit(1);
/* load in the source-to-label registration */
if (src2lblregfile != NULL) {
//err = regio_read_xfm(src2lblregfile, &Msrc2lbl);
//if(err) exit(1);
lta = LTAread(src2lblregfile);
if (lta->type == LINEAR_VOX_TO_VOX) {
printf("INFO: converting LTA to RAS\n");
LTAvoxelTransformToCoronalRasTransform(lta);
}
Msrc2lbl = MatrixCopy(lta->xforms[0].m_L,NULL);
} else if (labeltal) {
/* Load the talairach.xfm and make it approp for reg.dat*/
Msrc2lbl = DevolveXFM(srcsubject,NULL,talxfm);
if (Msrc2lbl==NULL) exit(1);
} else Msrc2lbl = NULL;
if (Msrc2lbl != NULL) {
printf("-- Source2Label %s ---- \n",src2lblregfile);
MatrixPrint(stdout,Msrc2lbl);
printf("-------------------------------\n");
}
} else {
Label = NULL;
Msrc2lbl = NULL;
}
/* -------------- load mask volume stuff -----------------------------*/
if (mskvolid != NULL) {
/* load the mask volume (single frame) */
printf("Reading %s\n",mskvolid);
mMskVol = MRIread(mskvolid);
if(mMskVol == NULL) exit(1);
if(mskframe > 0){
mritmp = fMRIframe(mMskVol, mskframe, NULL);
if(mritmp == NULL) exit(1);
MRIfree(&mMskVol);
mMskVol = mritmp;
}
/* Qmsk: Compute the quantization matrix for msk volume */
/* crsFOV = Qmsk*xyzFOV */
Qmsk = FOVQuantMatrix(mMskVol->width, mMskVol->height, mMskVol->depth,
mMskVol->xsize, mMskVol->ysize, mMskVol->zsize);
/* get the mask2source registration information */
/* xyzSrc = Mmsk2src * xyzMsk */
if (msk2srcregfile != NULL) {
err = regio_read_mincxfm(msk2srcregfile, &Mmsk2src, NULL);
if (err) exit(1);
} else Mmsk2src = NULL;
/* convert from Mask Anatomical to Src FOV */
if (!msksamesrc) {
mSrcMskVol = vol2vol_linear(mMskVol, Qmsk, NULL, NULL, Dmsk,
Qsrc, Fsrc, Wsrc, Dsrc,
mSrcVol->height, mSrcVol->width, mSrcVol->depth,
Mmsk2src, INTERP_NEAREST, float2int_msk);
if (mSrcMskVol == NULL) exit(1);
} else mSrcMskVol = mMskVol;
/* binarize the mask volume */
mri_binarize(mSrcMskVol, mskthresh, msktail, mskinvert,
mSrcMskVol, &nmskhits);
} else {
mSrcMskVol = NULL;
nmskhits = 0;
}
/*-------------- Done loading mask stuff -------------------------*/
/* If this is a statistical volume, raise each frame to it's appropriate
power (eg, stddev needs to be squared)*/
if (is_sxa_volume(srcvolid)) {
printf("INFO: Source volume detected as selxavg format\n");
sxa = ld_sxadat_from_stem(srcvolid);
if (sxa == NULL) exit(1);
framepower = sxa_framepower(sxa,&f);
if (f != mSrcVol->nframes) {
fprintf(stderr," number of frames is incorrect (%d,%d)\n",
f,mSrcVol->nframes);
exit(1);
}
printf("INFO: Adjusting Frame Power\n");
fflush(stdout);
mri_framepower(mSrcVol,framepower);
}
/*--------- Prepare the final mask ------------------------*/
if (Label != NULL) {
mFinalMskVol = label2mask_linear(mSrcVol, Qsrc, Fsrc, Wsrc,
Dsrc, mSrcMskVol,
Msrc2lbl, Label, labelfillthresh, float2int_src,
&nlabelhits, &nfinalhits);
if (mFinalMskVol == NULL) exit(1);
} else {
mFinalMskVol = mSrcMskVol;
nfinalhits = nmskhits;
}
if (!oldtxtstyle) {
/* count the number of functional voxels = 1 in the mask */
nfinalhits = 0;
for (r=0;r<mFinalMskVol->height;r++) {
for (c=0;c<mFinalMskVol->width;c++) {
for (s=0;s<mFinalMskVol->depth;s++) {
val = MRIgetVoxVal(mFinalMskVol,c,r,s,0);
if (val > 0.5) nfinalhits ++;
}
}
}
if (Label != NULL)
nlabelhits = CountLabelHits(mSrcVol, Qsrc, Fsrc,
Wsrc, Dsrc, Msrc2lbl,
Label, labelfillthresh,float2int_src);
else nlabelhits = 0;
}
/*-------------------------------------------------------*/
/*--------- Map the volume into the ROI -----------------*/
printf("Averging over ROI\n");
fflush(stdout);
mROI = vol2maskavg(mSrcVol, mFinalMskVol,&nhits);
if (mROI == NULL) exit(1);
printf("Done averging over ROI (nhits = %d)\n",nhits);
/*-------------------------------------------------------*/
/* ------- Save the final mask ------------------ */
if (finalmskvolid != 0) {
//mri_save_as_bvolume(mFinalMskVol,finalmskvolid,endian,BF_FLOAT);
//MRIwriteAnyFormat(mFinalMskVol,finalmskvolid,"bfloat",-1,NULL);
sprintf(tmpstr,"%s.%s",finalmskvolid,outext);
MRIwrite(mFinalMskVol,tmpstr);
}
/* ------- Save CRS of the the final mask ------------------ */
if (finalmskcrs != NULL) {
fp = fopen(finalmskcrs,"w");
if (fp==NULL) {
fprintf(stderr,"ERROR: cannot open %s\n",finalmskcrs);
exit(1);
}
for (r=0;r<mFinalMskVol->height;r++) {
for (c=0;c<mFinalMskVol->width;c++) {
for (s=0;s<mFinalMskVol->depth;s++) {
val = MRIgetVoxVal(mFinalMskVol,c,r,s,0);
if (val > 0.5) {
fprintf(fp,"%d %d %d\n",c,r,s);
}
}
}
}
fclose(fp);
}
/* If this is a statistical volume, lower each frame to it's appropriate
power (eg, variance needs to be sqrt'ed) */
if (is_sxa_volume(srcvolid)) {
printf("INFO: Readjusting Frame Power\n");
fflush(stdout);
for (f=0; f < mROI->nframes; f++) framepower[f] = 1.0/framepower[f];
mri_framepower(mROI,framepower);
}
/* save the target volume in an appropriate format */
if(roifile != NULL){
sprintf(tmpstr,"%s.%s",roifile,outext);
MRIwrite(mROI,tmpstr);
/* for a stat volume, save the .dat file */
if (is_sxa_volume(srcvolid)) {
sxa->nrows = 1;
sxa->ncols = 1;
sv_sxadat_by_stem(sxa,roifile);
}
}
/* save as text */
if(roitxtfile != NULL) {
fp = fopen(roitxtfile,"w");
if (fp==NULL) {
fprintf(stderr,"ERROR: cannot open %s\n",roitxtfile);
exit(1);
}
if (oldtxtstyle) {
printf("INFO: saving as old style txt\n");
fprintf(fp,"%d \n",nmskhits);
}
if (! plaintxtstyle ) {
fprintf(fp,"%d \n",nlabelhits);
fprintf(fp,"%d \n",nfinalhits);
}
for (f=0; f < mROI->nframes; f++)
fprintf(fp,"%f\n",MRIgetVoxVal(mROI,0,0,0,f));
fclose(fp);
}
/* ------- Mask the source and save it ------------------ */
if (srcmskvolid != 0) {
for (r=0;r<mFinalMskVol->height;r++) {
for (c=0;c<mFinalMskVol->width;c++) {
for (s=0;s<mFinalMskVol->depth;s++) {
val = MRIgetVoxVal(mFinalMskVol,c,r,s,0);
if (val < 0.5) {
for (f=0; f < mROI->nframes; f++)
MRIFseq_vox(mSrcVol,c,r,s,f) = 0.0;
}
}
}
}
MRIwrite(mSrcVol,srcmskvolid);
}
/* ------- Save as a text list ------------------ */
if (ListFile != 0) {
fp = fopen(ListFile,"w");
for (c=0;c<mFinalMskVol->width;c++) {
for (r=0;r<mFinalMskVol->height;r++) {
for (s=0;s<mFinalMskVol->depth;s++) {
val = MRIFseq_vox(mFinalMskVol,c,r,s,0);
if(val < 0.5) continue;
fprintf(fp,"%3d %3d %3d ",c,r,s);
for (f=0; f < mROI->nframes; f++){
val = MRIgetVoxVal(mSrcVol,c,r,s,f);
fprintf(fp,"%f ",val);
}
fprintf(fp,"\n");
}
}
}
fclose(fp);
}
return(0);
}
/*---------------------------------------------------------------*/
int main(int argc, char **argv) {
char *srcsubj;
float betplaneres, inplaneres, intensity;
MATRIX *R, *Xsrc, *invXsrc, *Xtarg, *Rtarg;
int float2int, err;
Progname = argv[0] ;
argc --;
argv++;
ErrorInit(NULL, NULL, NULL) ;
DiagInit(NULL, NULL, NULL) ;
if (argc == 0) usage_exit();
parse_commandline(argc, argv);
check_options();
dump_options(stdout);
/* Load the registration matrix, fix if necessary */
err = regio_read_register(srcregpath, &srcsubj, &inplaneres,
&betplaneres, &intensity, &R,
&float2int);
if (err) exit(1);
printf("---- Input registration matrix --------\n");
MatrixPrint(stdout,R);
if (float2int == FLT2INT_TKREG && fixtkreg) {
if (fvolid == NULL) {
printf("ERROR: the input registration file requires that you "
"supply an example functional volume with --fvol\n");
exit(1);
}
FuncMRI = MRIreadHeader(fvolid,MRI_VOLUME_TYPE_UNKNOWN);
if (FuncMRI==NULL) exit(1);
printf("INFO: making tkreg matrix compatible with round\n");
R = MRIfixTkReg(FuncMRI,R);
printf("---- Fixed input registration matrix --------\n");
MatrixPrint(stdout,R);
}
float2int = FLT2INT_ROUND;
/* Load the source subject xfm */
Xsrc = DevolveXFM(srcsubj,NULL,xfmrname);
if (Xsrc == NULL) exit(1);
invXsrc = MatrixInverse(Xsrc,NULL);
/* Load the target subject xfm */
Xtarg = DevolveXFM(targsubj,NULL,xfmrname);
if (Xtarg == NULL) exit(1);
/* Rtarg = R*inv(Xsrc)*Xtarg */
Rtarg = MatrixMultiply(R,invXsrc,NULL);
Rtarg = MatrixMultiply(Rtarg,Xtarg,Rtarg);
printf("---- New registration matrix --------\n");
MatrixPrint(stdout,Rtarg);
err = regio_write_register(targregpath, targsubj, inplaneres,
betplaneres, intensity, Rtarg, float2int);
if (err) {
printf("ERROR: could not write to %s\n",targregpath);
exit(1);
}
return(0);
exit(0);
}
int
main(int argc, char *argv[]) {
char **av, fname[STRLEN] ;
int ac, nargs ;
char *reg_fname, *in_fname, *out_stem, *cp ;
int msec, minutes, seconds, nvox, float2int ;
struct timeb start ;
MRI_SURFACE *mris_lh_white, *mris_rh_white, *mris_lh_pial, *mris_rh_pial ;
MRI *mri_aseg, *mri_seg, *mri_pial, *mri_tmp, *mri_ribbon, *mri_in, *mri_cortex,
*mri_subcort_gm, *mri_wm, *mri_csf ;
MATRIX *m_regdat ;
float intensity, betplaneres, inplaneres ;
/* rkt: check for and handle version tag */
nargs = handle_version_option (argc, argv, "$Id: mri_compute_volume_fractions.c,v 1.9 2012/11/07 18:58:02 greve Exp $", "$Name: $");
if (nargs && argc - nargs == 1)
exit (0);
argc -= nargs;
Progname = argv[0] ;
ac = argc ;
av = argv ;
for ( ; argc > 1 && ISOPTION(*argv[1]) ; argc--, argv++) {
nargs = get_option(argc, argv) ;
argc -= nargs ;
argv += nargs ;
}
if (argc < 4)
usage_exit(1) ;
if (!strlen(sdir)) {
cp = getenv("SUBJECTS_DIR") ;
if (!cp)
ErrorExit(ERROR_BADPARM,
"%s: SUBJECTS_DIR not defined in environment.\n", Progname) ;
strcpy(sdir, cp) ;
}
reg_fname = argv[1] ; in_fname = argv[2] ;
out_stem = argv[3] ; Progname = argv[0] ;
ErrorInit(NULL, NULL, NULL) ;
DiagInit(NULL, NULL, NULL) ;
TimerStart(&start) ;
if (stricmp(reg_fname, "identity.nofile") == 0)
{
printf("using identity transform\n") ;
m_regdat = NULL ;
inplaneres = betplaneres = intensity = 1 ;
float2int = 0 ;
if (subject == NULL)
subject = "unknown" ;
}
else
{
char *saved_subject = subject ;
printf("reading registration file %s\n", reg_fname) ;
regio_read_register(reg_fname, &subject, &inplaneres,
&betplaneres, &intensity, &m_regdat,
&float2int);
if (saved_subject) // specified on cmdline
subject = saved_subject ;
m_regdat = regio_read_registermat(reg_fname) ;
if (m_regdat == NULL)
ErrorExit(ERROR_NOFILE, "%s: could not load registration file from %s", Progname,reg_fname) ;
}
printf("Format is %s\n",fmt);
sprintf(fname, "%s/%s/surf/lh.white", sdir, subject) ;
printf("reading surface %s\n", fname) ;
mris_lh_white = MRISread(fname) ;
if (mris_lh_white == NULL)
ErrorExit(ERROR_NOFILE, "%s: could not load lh white surface from %s", Progname,fname) ;
sprintf(fname, "%s/%s/surf/rh.white", sdir, subject) ;
printf("reading surface %s\n", fname) ;
mris_rh_white = MRISread(fname) ;
if (mris_rh_white == NULL)
ErrorExit(ERROR_NOFILE, "%s: could not load rh white surface from %s", Progname,fname) ;
sprintf(fname, "%s/%s/surf/lh.pial", sdir, subject) ;
printf("reading surface %s\n", fname) ;
mris_lh_pial = MRISread(fname) ;
if (mris_lh_pial == NULL)
ErrorExit(ERROR_NOFILE, "%s: could not load lh pial surface from %s", Progname,fname) ;
sprintf(fname, "%s/%s/surf/rh.pial", sdir, subject) ;
printf("reading surface %s\n", fname) ;
mris_rh_pial = MRISread(fname) ;
if (mris_rh_pial == NULL)
ErrorExit(ERROR_NOFILE, "%s: could not load rh pial surface from %s", Progname,fname) ;
sprintf(fname, "%s/%s/mri/aseg.mgz", sdir, subject) ;
printf("reading volume %s\n", fname) ;
mri_aseg = MRIread(fname) ;
if (mri_aseg == NULL)
ErrorExit(ERROR_NOFILE, "%s: could not load aseg volume from %s", Progname,fname) ;
printf("reading movable volume %s\n", in_fname) ;
mri_in = MRIread(in_fname) ;
if (mri_in == NULL)
ErrorExit(ERROR_NOFILE, "%s: could not load input volume from %s", Progname,in_fname) ;
nvox = (int)ceil(256/resolution);
mri_pial = MRIalloc(nvox, nvox, nvox, MRI_UCHAR) ;
MRIsetResolution(mri_pial, resolution, resolution, resolution) ;
mri_pial->xstart = -resolution*mri_pial->width/2.0 ;
mri_pial->xend = resolution*mri_pial->width/2.0 ;
mri_pial->ystart = -resolution*mri_pial->height/2.0 ;
mri_pial->yend = resolution*mri_pial->height/2.0 ;
mri_pial->zstart = -resolution*mri_pial->depth/2.0 ;
mri_pial->zend = resolution*mri_pial->depth/2 ;
mri_pial->c_r = mri_aseg->c_r ; mri_pial->c_a = mri_aseg->c_a ; mri_pial->c_s = mri_aseg->c_s ;
MRIreInitCache(mri_pial) ;
printf("filling interior of lh pial surface...\n") ;
MRISfillInterior(mris_lh_pial, resolution, mri_pial) ;
mri_seg = MRIclone(mri_pial, NULL) ;
mri_tmp = MRIclone(mri_pial, NULL) ;
printf("filling interior of rh pial surface...\n") ;
MRISfillInterior(mris_rh_pial, resolution, mri_tmp) ;
MRIcopyLabel(mri_tmp, mri_pial, 1) ;
MRIclear(mri_tmp) ;
printf("filling interior of lh white matter surface...\n") ;
MRISfillWhiteMatterInterior(mris_lh_white, mri_aseg, mri_seg, resolution,
WM_VAL, SUBCORT_GM_VAL, CSF_VAL);
printf("filling interior of rh white matter surface...\n") ;
MRISfillWhiteMatterInterior(mris_rh_white, mri_aseg, mri_tmp, resolution,
WM_VAL, SUBCORT_GM_VAL, CSF_VAL);
MRIcopyLabel(mri_tmp, mri_seg, WM_VAL) ;
MRIcopyLabel(mri_tmp, mri_seg, SUBCORT_GM_VAL) ;
MRIcopyLabel(mri_tmp, mri_seg, CSF_VAL) ;
MRIfree(&mri_tmp) ;
mri_ribbon = MRInot(mri_seg, NULL) ;
MRIcopyLabel(mri_seg, mri_pial, CSF_VAL) ;
MRIreplaceValuesOnly(mri_pial, mri_pial, CSF_VAL, 0) ;
MRIand(mri_ribbon, mri_pial, mri_ribbon, 1) ;
MRIbinarize(mri_ribbon, mri_ribbon, 1, 0, GM_VAL) ;
MRIcopyLabel(mri_ribbon, mri_seg, GM_VAL) ;
MRIreplaceValuesOnly(mri_seg, mri_seg, CSF_VAL, 0) ;
add_aseg_structures_outside_ribbon(mri_seg, mri_aseg, mri_seg, WM_VAL, SUBCORT_GM_VAL, CSF_VAL) ;
{
MATRIX *m_conformed_to_epi_vox2vox, *m_seg_to_conformed_vox2vox,
*m_seg_to_epi_vox2vox ;
if (m_regdat == NULL) // assume identity transform
m_seg_to_epi_vox2vox = MRIgetVoxelToVoxelXform(mri_seg, mri_in) ;
else
{
m_conformed_to_epi_vox2vox = MRIvoxToVoxFromTkRegMtx(mri_in, mri_aseg, m_regdat);
m_seg_to_conformed_vox2vox = MRIgetVoxelToVoxelXform(mri_seg, mri_aseg) ;
m_seg_to_epi_vox2vox = MatrixMultiply(m_conformed_to_epi_vox2vox, m_seg_to_conformed_vox2vox, NULL) ;
MatrixFree(&m_regdat) ; MatrixFree(&m_conformed_to_epi_vox2vox) ;
MatrixFree(&m_seg_to_conformed_vox2vox);
}
printf("seg to EPI vox2vox matrix:\n") ;
MatrixPrint(Gstdout, m_seg_to_epi_vox2vox) ;
mri_cortex = MRIalloc(mri_in->width, mri_in->height, mri_in->depth, MRI_FLOAT) ;
MRIcopyHeader(mri_in, mri_cortex) ;
mri_subcort_gm = MRIclone(mri_cortex, NULL) ;
mri_wm = MRIclone(mri_cortex, NULL) ;
mri_csf = MRIclone(mri_cortex, NULL) ;
printf("computing partial volume fractions...\n") ;
MRIcomputePartialVolumeFractions(mri_in, m_seg_to_epi_vox2vox, mri_seg, mri_wm, mri_subcort_gm, mri_cortex, mri_csf,
WM_VAL, SUBCORT_GM_VAL, GM_VAL, 0) ;
}
sprintf(fname, "%s.wm.%s", out_stem,fmt) ;
printf("writing wm %% to %s\n", fname) ;
MRIwrite(mri_wm, fname) ;
sprintf(fname, "%s.subcort_gm.%s", out_stem,fmt) ;
printf("writing subcortical gm %% to %s\n", fname) ;
MRIwrite(mri_subcort_gm, fname) ;
sprintf(fname, "%s.cortex.%s", out_stem, fmt) ;
printf("writing cortical gm %% to %s\n", fname) ;
MRIwrite(mri_cortex, fname) ;
sprintf(fname, "%s.csf.%s", out_stem,fmt) ;
printf("writing csf %% to %s\n", fname) ;
MRIwrite(mri_csf, fname) ;
msec = TimerStop(&start) ;
seconds = nint((float)msec/1000.0f) ;
minutes = seconds / 60 ;
seconds = seconds % 60 ;
printf("volume fraction calculation took %d minutes"
" and %d seconds.\n", minutes, seconds) ;
exit(0) ;
return(0) ;
}
