static MRI *
add_interior_points(MRI *mri_src, MRI *mri_vals, float intensity_above,
float intensity_below, MRI_SURFACE *mris_white1,
MRI_SURFACE *mris_white2,
MRI *mri_aseg, MRI *mri_dst)
{
int x, y, z, ctrl, label, i ;
float val ;
MRI *mri_core ;
MRI *mri_interior, *mri_tmp ;
mri_interior = MRIclone(mri_src, NULL) ;
MRISfillInterior(mris_white1, mri_src->xsize, mri_interior) ;
mri_tmp = MRIclone(mri_src, NULL) ;
MRISfillInterior(mris_white2, mri_src->xsize, mri_tmp) ;
MRIcopyLabel(mri_tmp, mri_interior, 1) ;
if (Gdiag & DIAG_WRITE && DIAG_VERBOSE_ON)
{
MRIwrite(mri_interior, "i.mgz") ;
}
mri_core = MRIerode(mri_interior, NULL) ;
for (i = 1 ; i < nint(1.0/mri_src->xsize) ; i++)
{
MRIcopy(mri_core, mri_tmp) ;
MRIerode(mri_tmp, mri_core) ;
}
MRIfree(&mri_tmp) ;
if (mri_aseg == NULL)
{
for (x = 0 ; x < mri_src->width ; x++)
for (y = 0 ; y < mri_src->height ; y++)
for (z = 0 ; z < mri_src->depth ; z++)
{
if (Gx == x && Gy == y && Gz == z)
{
DiagBreak() ;
}
ctrl = MRIgetVoxVal(mri_core, x, y, z, 0) ;
if (ctrl > 0)
{
MRIsetVoxVal(mri_dst, x, y, z, 0, ctrl) ;
}
}
}
else
{
for (x = 0 ; x < mri_src->width ; x++)
for (y = 0 ; y < mri_src->height ; y++)
for (z = 0 ; z < mri_src->depth ; z++)
{
if (Gx == x && Gy == y && Gz == z)
{
DiagBreak() ;
}
ctrl = MRIgetVoxVal(mri_src, x, y, z, 0) ;
if (ctrl == 0) // add in some missed ones that are inside the surface
{
label = MRIgetVoxVal(mri_aseg, x, y, z, 0) ;
if (IS_GM(label) || IS_WM(label))
{
val = MRIgetVoxVal(mri_vals, x, y, z, 0) ;
if ((val >= 110-intensity_below && val <= 110 + intensity_above)&&
MRIgetVoxVal(mri_core, x, y, z, 0) > 0)
{
ctrl = 1 ;
}
}
}
MRIsetVoxVal(mri_dst, x, y, z, 0, ctrl) ;
}
}
MRIfree(&mri_core) ;
return(mri_dst) ;
}
MRI*
MRIcomputeVolumeFractionFromSurface(MRI_SURFACE *mris, double acc, MRI *mri_src, MRI *mri_fractions)
{
const int width = mri_src->width;
const int height = mri_src->height;
const int depth = mri_src->depth;
int x,y,z, vno;
double xs, ys, zs, dist;
MRIS_HASH_TABLE *mht;
VERTEX *v;
/* preparing the output */
printf("preparing the output\n");
if (mri_fractions == NULL)
{
mri_fractions = MRIalloc(width,height,depth,MRI_FLOAT);
MRIcopyHeader(mri_src, mri_fractions);
}
MRI *mri_shell, *mri_interior;
/* creating a shell from the surface */
printf("computing the shell\n");
mri_shell = MRIclone(mri_src, NULL);
mri_shell = MRISshell(mri_src, mris, mri_shell, 1);
/* creating an interior image from the surface */
printf("computing an interior image\n");
mri_interior = MRIclone(mri_src, NULL);
MRIclear(mri_interior);
mri_interior = MRISfillInterior(mris, 0.0, mri_interior);
/* creating the hash table related to the surface vertices */
printf("computing the hash table\n");
mht = MHTfillVertexTableRes(mris, NULL, CURRENT_VERTICES, 10);
/* looping over the nonzero elements of the shell */
printf("computing the fractions\n");
volFraction frac;
octTreeVoxel V;
double vox[3], vsize[3];
vsize[0] = mri_src->xsize; vsize[1] = mri_src->ysize; vsize[2] = mri_src->zsize;
for (x = 0; x < width; x++)
{
for (y = 0; y < height; y++)
{
for (z = 0; z < depth; z++)
{
if (MRIgetVoxVal (mri_shell, x, y, z, 0) > 125.0)
{
/* change of coordinates from image to surface domain */
MRIvoxelToSurfaceRAS(mri_shell, x, y, z, &xs, &ys, &zs);
/* find the closest vertex to the point */
MHTfindClosestVertexGeneric(mht, mris, xs, ys, zs, 10, 2, &v, &vno, &dist);
/* creating the oct tree voxel structure */
vox[0] = xs - vsize[0] / 2.0;
vox[1] = ys - vsize[1] / 2.0;
vox[2] = zs - vsize[2] / 2.0;
V = octTreeVoxelCreate(vox,vsize);
/* compute the volume fraction of this voxel */
frac = MRIcomputeVoxelFractions( V, v, acc, 1, mris);
MRIsetVoxVal(mri_fractions,x,y,z,0,frac.frac);
}
else if(MRIgetVoxVal(mri_interior,x,y,z,0) > 0.0)
MRIsetVoxVal(mri_fractions,x,y,z,0,1.0);
}
}
}
return mri_fractions;
}
int
insert_ribbon_into_aseg(MRI *mri_src_aseg, MRI *mri_aseg,
MRI_SURFACE *mris_white, MRI_SURFACE *mris_pial,
int hemi)
{
MRI *mri_ribbon, *mri_white ;
int x, y, z, gm_label, wm_label, label, nbr_label, dont_change ;
if (mri_src_aseg != mri_aseg)
mri_aseg = MRIcopy(mri_src_aseg, mri_aseg) ;
gm_label = hemi == LEFT_HEMISPHERE ?
Left_Cerebral_Cortex : Right_Cerebral_Cortex ;
wm_label = hemi == LEFT_HEMISPHERE ?
Left_Cerebral_White_Matter : Right_Cerebral_White_Matter ;
mri_white = MRIclone(mri_aseg, NULL) ;
mri_ribbon = MRISribbon(mris_white, mris_pial, mri_aseg, NULL) ;
MRISfillInterior(mris_white, mri_aseg->xsize, mri_white) ;
for (x = 0 ; x < mri_aseg->width ; x++)
for (y = 0 ; y < mri_aseg->height ; y++)
for (z = 0 ; z < mri_aseg->depth ; z++)
{
if (x == Gx && y == Gy && z == Gz)
DiagBreak() ;
label = nint(MRIgetVoxVal(mri_aseg, x, y, z, 0)) ;
if (nint(MRIgetVoxVal(mri_ribbon, x, y, z, 0)) == 255) // in ribbon, set to GM
{
if (IS_CORTEX(label) || IS_WHITE_CLASS(label))
{
int xi, yi, zi, xk, yk, zk ;
// check to make sure we are really in cortex
for (dont_change = 0, xk = -1 ; xk <= 1 ; xk++)
{
xi = mri_aseg->xi[xk+x] ;
for (yk = -1 ; yk <= 1 ; yk++)
{
yi = mri_aseg->yi[yk+y] ;
for (zk = -1 ; zk <= 1 ; zk++)
{
zi = mri_aseg->zi[zk+z] ;
nbr_label = (int)MRIgetVoxVal(mri_aseg, xi, yi, zi, 0) ;
switch (nbr_label)
{
default:
break ;
case Left_Hippocampus:
case Right_Hippocampus:
case Left_Amygdala:
case Right_Amygdala:
case Left_VentralDC:
case Right_VentralDC:
case Brain_Stem:
case Left_Lateral_Ventricle:
case Right_Lateral_Ventricle:
case Left_Inf_Lat_Vent:
case Right_Inf_Lat_Vent:
case Left_Thalamus_Proper:
case Right_Thalamus_Proper:
case Left_choroid_plexus:
case Right_choroid_plexus:
case CC_Posterior:
case CC_Mid_Posterior:
case CC_Central:
case CC_Mid_Anterior:
case CC_Anterior:
dont_change = 1 ;
break ;
}
}
}
}
if (dont_change == 0)
MRIsetVoxVal(mri_aseg, x, y, z, 0, gm_label) ;
}
}
else // not in ribbon
{
if (MRIgetVoxVal(mri_white, x, y, z, 0) > 0) // inside white surface - disambiguate
{
if (label == gm_label) // gm inside white surface should be wm
MRIsetVoxVal(mri_aseg, x, y, z, 0, wm_label) ;
}
else if (label == gm_label) // gm outside ribbon should be unknown
MRIsetVoxVal(mri_aseg, x, y, z, 0, Unknown) ;
}
}
if (Gdiag & DIAG_WRITE && DIAG_VERBOSE_ON)
{
MRIwrite(mri_ribbon, "r.mgz") ;
MRIwrite(mri_white, "w.mgz");
}
MRIfree(&mri_ribbon) ; MRIfree(&mri_white) ;
return(NO_ERROR) ;
}
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) ;
}
FCD_DATA *
FCDloadData(char *sdir, char *subject)
{
FCD_DATA *fcd ;
char fname[STRLEN] ;
MRI *mri_interior, *mri_dist, *mri_int_lh, *mri_int_rh, *mri_pvals ;
fcd = (FCD_DATA *)calloc(1, sizeof(FCD_DATA)) ;
sprintf(fname, "%s/%s/surf/lh.white", sdir, subject) ;
fcd->mris_lh = MRISread(fname) ;
if (fcd->mris_lh == NULL)
{
ErrorExit(ERROR_NOFILE, "FCDloadData: couldn't load %s", fname) ;
}
MRISsaveVertexPositions(fcd->mris_lh, WHITE_VERTICES) ;
if (MRISreadPialCoordinates(fcd->mris_lh, "pial") != NO_ERROR)
{
ErrorExit(ERROR_NOFILE, "FCDloadData: couldn't load lh pial vertices") ;
}
sprintf(fname, "%s/%s/surf/lh.pial", sdir, subject) ;
fcd->mris_lh_pial = MRISread(fname) ;
if (fcd->mris_lh_pial == NULL)
{
ErrorExit(ERROR_NOFILE, "FCDloadData: couldn't load %s", fname) ;
}
sprintf(fname, "%s/%s/surf/lh.sphere.d1.left_right", sdir, subject) ;
fcd->mris_lh_sphere_d1 = MRISread(fname) ;
if (fcd->mris_lh_sphere_d1 == NULL)
{
ErrorExit(ERROR_NOFILE, "FCDloadData: couldn't load %s", fname) ;
}
exec_progress_callback(1, 12, 0, 1) ;
sprintf(fname, "%s/%s/surf/rh.white", sdir, subject) ;
fcd->mris_rh = MRISread(fname) ;
if (fcd->mris_rh == NULL)
{
ErrorExit(ERROR_NOFILE, "FCDloadData: couldn't load %s", fname) ;
}
MRISsaveVertexPositions(fcd->mris_rh, WHITE_VERTICES) ;
if (MRISreadPialCoordinates(fcd->mris_rh, "pial") != NO_ERROR)
{
ErrorExit(ERROR_NOFILE, "FCDloadData: couldn't load rh pial vertices") ;
}
sprintf(fname, "%s/%s/surf/rh.pial", sdir, subject) ;
fcd->mris_rh_pial = MRISread(fname) ;
if (fcd->mris_rh_pial == NULL)
{
ErrorExit(ERROR_NOFILE, "FCDloadData: couldn't load %s", fname) ;
}
sprintf(fname, "%s/%s/surf/rh.sphere.d1.left_right", sdir, subject) ;
fcd->mris_rh_sphere_d1 = MRISread(fname) ;
if (fcd->mris_rh_sphere_d1 == NULL)
{
ErrorExit(ERROR_NOFILE, "FCDloadData: couldn't load %s", fname) ;
}
exec_progress_callback(2, 12, 0, 1) ;
sprintf(fname, "%s/%s/mri/aseg.mgz", sdir, subject) ;
fcd->mri_aseg = MRIread(fname) ;
if (fcd->mri_aseg == NULL)
{
ErrorExit(ERROR_NOFILE, "FCDloadData: couldn't load %s", fname) ;
}
exec_progress_callback(3, 12, 0, 1) ;
sprintf(fname, "%s/%s/mri/aparc+aseg.mgz", sdir, subject) ;
fcd->mri_aparc = MRIread(fname) ;
if (fcd->mri_aparc == NULL)
{
ErrorExit(ERROR_NOFILE, "FCDloadData: couldn't load %s", fname) ;
}
exec_progress_callback(4, 12, 0, 1) ;
fcd->mri_flair = NULL;
sprintf(fname, "%s/%s/mri/flair.reg.norm.mgz", sdir, subject) ;
if ( ! FileExists(fname))
{
sprintf(fname, "%s/%s/mri/FLAIR.mgz", sdir, subject) ;
if ( ! FileExists(fname))
{
sprintf(fname, "%s/%s/mri/FLAIRax.mgz", sdir, subject) ;
if ( ! FileExists(fname))
{
sprintf(fname, "%s/%s/mri/FLAIRcor.mgz", sdir, subject) ;
if ( ! FileExists(fname))
{
sprintf(fname, " ");
}
}
}
}
if (strlen(fname) > 1)
{
fcd->mri_flair = MRIread(fname) ;
if (fcd->mri_flair == NULL)
{
ErrorExit(ERROR_NOFILE, "FCDloadData: couldn't load $s", fname) ;
}
}
fcd->mri_t2 = NULL;
sprintf(fname, "%s/%s/mri/T2.mgz", sdir, subject) ;
if ( ! FileExists(fname))
{
sprintf(fname, "%s/%s/mri/T2ax.mgz", sdir, subject) ;
if ( ! FileExists(fname))
{
sprintf(fname, "%s/%s/mri/T2cor.mgz", sdir, subject) ;
if ( ! FileExists(fname))
{
sprintf(fname, " ");
}
}
}
if (strlen(fname) > 1)
{
fcd->mri_t2 = MRIread(fname) ;
if (fcd->mri_t2 == NULL)
{
ErrorExit(ERROR_NOFILE, "FCDloadData: couldn't load $s", fname) ;
}
}
exec_progress_callback(5, 12, 0, 1) ;
sprintf(fname, "%s/%s/mri/norm.mgz", sdir, subject) ;
fcd->mri_norm = MRIread(fname) ;
if (fcd->mri_norm == NULL)
{
ErrorExit(ERROR_NOFILE, "FCDloadData: couldn't load %s", fname) ;
}
fcd->mri_thickness_increase =
MRIcloneDifferentType(fcd->mri_aseg, MRI_FLOAT) ;
fcd->mri_thickness_decrease =
MRIcloneDifferentType(fcd->mri_aseg, MRI_FLOAT) ;
fcd->mri_thickness_difference = MRIadd(fcd->mri_thickness_increase, fcd->mri_thickness_decrease, NULL);
exec_progress_callback(6, 12, 0, 1) ;
sprintf(fname, "%s/%s/surf/lh.rh.thickness.smooth0.mgz", sdir, subject) ;
fcd->rh_thickness_on_lh = MRIread(fname) ;
if (fcd->mri_aseg == NULL)
{
ErrorExit(ERROR_NOFILE, "FCDloadData: couldn't load %s", fname) ;
}
exec_progress_callback(7, 12, 0, 1) ;
sprintf(fname, "%s/%s/surf/rh.thickness.mgz", sdir, subject) ;
fcd->rh_thickness_on_rh = MRIread(fname) ;
if (fcd->rh_thickness_on_rh == NULL)
{
ErrorExit(ERROR_NOFILE, "FCDloadData: couldn't load %s", fname) ;
}
exec_progress_callback(8, 12, 0, 1) ;
sprintf(fname, "%s/%s/surf/lh.thickness.mgz", sdir, subject) ;
fcd->lh_thickness_on_lh = MRIread(fname) ;
if (fcd->lh_thickness_on_lh == NULL)
{
ErrorExit(ERROR_NOFILE, "FCDloadData: couldn't load %s", fname) ;
}
exec_progress_callback(9, 12, 0, 1) ;
sprintf(fname, "%s/%s/surf/rh.lh.thickness.smooth0.mgz", sdir, subject) ;
if ( ! FileExists(fname))
{
sprintf(fname, "%s/%s/surf/rh.lh.thickness.mgz", sdir, subject) ;
if (fcd->lh_thickness_on_rh == NULL)
{
ErrorExit(ERROR_NOFILE, "FCDloadData: couldn't load %s", fname) ;
}
}
fcd->lh_thickness_on_rh = MRIread(fname) ;
exec_progress_callback(10, 12, 0, 1) ;
mri_int_lh = MRIclone(fcd->mri_norm, NULL) ;
mri_int_rh = MRIclone(fcd->mri_norm, NULL) ;
mri_interior = MRIclone(fcd->mri_norm, NULL) ;
mri_dist = MRIcloneDifferentType(mri_interior, MRI_FLOAT) ;
MRISrestoreVertexPositions(fcd->mris_lh, PIAL_VERTICES) ;
MRISrestoreVertexPositions(fcd->mris_rh, PIAL_VERTICES) ;
MRISfillInterior(fcd->mris_lh, mri_interior->xsize, mri_int_lh) ;
MRISfillInterior(fcd->mris_rh, mri_interior->xsize, mri_int_rh) ;
exec_progress_callback(11, 12, 0, 1) ;
MRIor(mri_int_lh, mri_int_rh, mri_interior, 0) ;
MRIfree(&mri_int_lh) ;
MRIfree(&mri_int_rh) ;
MRIbinarize(mri_interior, mri_interior, 1, 0, 1) ;
if (Gdiag & DIAG_WRITE)
{
MRIwrite(mri_interior, "int.mgz") ;
}
MRIdistanceTransform(mri_interior,
mri_dist,
1,
2*MAX_DIST,
DTRANS_MODE_SIGNED,
NULL);
if (Gdiag & DIAG_WRITE)
{
MRIwrite(mri_dist, "dist.mgz") ;
}
mri_pvals = build_distance_by_intensity_histo(fcd->mri_norm,
mri_dist,
fcd->mri_aseg,
DIST_SPACING,
MAX_DIST) ;
exec_progress_callback(12, 12, 0, 1) ;
augment_thicknesses(fcd, mri_pvals, 1.5, 5, 1) ;
MRISrestoreVertexPositions(fcd->mris_lh, WHITE_VERTICES) ;
MRISrestoreVertexPositions(fcd->mris_rh, WHITE_VERTICES) ;
MRIfree(&mri_dist) ;
MRIfree(&mri_interior) ;
MRIfree(&mri_pvals) ;
return(fcd) ;
}
