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) ; }