static MRI * create_distance_transforms(MRI *mri_source, MRI *mri_target, MRI *mri_all_dtrans, float max_dist, GCA_MORPH *gcam) { MRI *mri_dtrans, *mri_atlas_dtrans ; int frame ; char fname[STRLEN] ; mri_all_dtrans = MRIallocSequence(mri_source->width, mri_source->height, mri_source->depth, MRI_FLOAT, NDTRANS_LABELS) ; MRIcopyHeader(mri_target, mri_all_dtrans) ; for (frame = 0 ; frame < NDTRANS_LABELS ; frame++) { printf("creating distance transform for %s, frame %d...\n", cma_label_to_name(dtrans_labels[frame]), frame) ; mri_dtrans = MRIdistanceTransform(mri_source, NULL, dtrans_labels[frame], max_dist, DTRANS_MODE_SIGNED, NULL) ; sprintf(fname, "%s.mgz", cma_label_to_name(dtrans_labels[frame])) ; if (Gdiag & DIAG_WRITE && DIAG_VERBOSE_ON) MRIwrite(mri_dtrans, fname) ; MRIcopyFrame(mri_dtrans, mri_all_dtrans, 0, frame) ; mri_atlas_dtrans = MRIdistanceTransform(mri_target, NULL, dtrans_labels[frame], max_dist, DTRANS_MODE_SIGNED, NULL) ; MRInormalizeInteriorDistanceTransform(mri_atlas_dtrans, mri_dtrans, mri_atlas_dtrans) ; GCAMsetTargetDistancesForLabel(gcam, mri_target, mri_atlas_dtrans, dtrans_labels[frame]); MRIfree(&mri_dtrans) ; MRIfree(&mri_atlas_dtrans) ; } return(mri_all_dtrans) ; }
static MRI * MRIcomputeSurfaceDistanceIntensities(MRI_SURFACE *mris, MRI *mri_ribbon, MRI *mri_aparc, MRI *mri, MRI *mri_aseg, int whalf) { MRI *mri_features, *mri_binary, *mri_white_dist, *mri_pial_dist ; int vno, ngm, outside_of_ribbon, label0, label, ohemi_label, xi, yi, zi, xk, yk, zk, x0, y0, z0, hemi_label, assignable ; double xv, yv, zv, step_size, dist, thickness, wdist, pdist, snx, sny, snz, nx, ny, nz, xl, yl, zl, x, y, z, dot, angle ; VERTEX *v ; mri_features = MRIallocSequence(mris->nvertices, 1, 1, MRI_FLOAT, 1) ; // one samples inwards, one in ribbon, and one outside MRIcopyHeader(mri, mri_features) ; mri_binary = MRIcopy(mri_ribbon, NULL) ; mri_binary = MRIbinarize(mri_ribbon, NULL, 1, 0, 1) ; mri_pial_dist = MRIdistanceTransform(mri_binary, NULL, 1, max_pial_dist+1, DTRANS_MODE_SIGNED,NULL); if (Gdiag & DIAG_WRITE && DIAG_VERBOSE_ON) MRIwrite(mri_pial_dist, "pd.mgz") ; MRIclear(mri_binary) ; MRIcopyLabel(mri_ribbon, mri_binary, Left_Cerebral_White_Matter) ; MRIcopyLabel(mri_ribbon, mri_binary, Right_Cerebral_White_Matter) ; MRIbinarize(mri_binary, mri_binary, 1, 0, 1) ; mri_white_dist = MRIdistanceTransform(mri_binary, NULL, 1, max_white_dist+1, DTRANS_MODE_SIGNED,NULL); if (Gdiag & DIAG_WRITE && DIAG_VERBOSE_ON) MRIwrite(mri_white_dist, "wd.mgz") ; if (mris->hemisphere == LEFT_HEMISPHERE) { ohemi_label = Right_Cerebral_Cortex ; hemi_label = Left_Cerebral_Cortex ; } else { hemi_label = Right_Cerebral_Cortex ; ohemi_label = Left_Cerebral_Cortex ; } step_size = mri->xsize/2 ; for (vno = 0 ; vno < mris->nvertices ; vno++) { v = &mris->vertices[vno] ; if (vno == Gdiag_no) DiagBreak() ; if (v->ripflag) continue ; // not cortex nx = v->pialx - v->whitex ; ny = v->pialy - v->whitey ; nz = v->pialz - v->whitez ; thickness = sqrt(nx*nx + ny*ny + nz*nz) ; if (FZERO(thickness)) continue ; // no cortex here x = (v->pialx + v->whitex)/2 ; y = (v->pialy + v->whitey)/2 ; z = (v->pialz + v->whitez)/2 ; // halfway between white and pial is x0 MRISsurfaceRASToVoxelCached(mris, mri_aseg, x, y, z, &xl, &yl, &zl) ; x0 = nint(xl); y0 = nint(yl) ; z0 = nint(zl) ; label0 = MRIgetVoxVal(mri_aparc, x0, y0, z0,0) ; // compute surface normal in voxel coords MRISsurfaceRASToVoxelCached(mris, mri_aseg, x+v->nx, y+v->ny, z+v->nz, &snx, &sny, &snz) ; snx -= xl ; sny -= yl ; snz -= zl ; for (ngm = 0, xk = -whalf ; xk <= whalf ; xk++) { xi = mri_aseg->xi[x0+xk] ; for (yk = -whalf ; yk <= whalf ; yk++) { yi = mri_aseg->yi[y0+yk] ; for (zk = -whalf ; zk <= whalf ; zk++) { zi = mri_aseg->zi[z0+zk] ; label = MRIgetVoxVal(mri_aseg, xi, yi, zi,0) ; if (xi == Gx && yi == Gy && zi == Gz) DiagBreak() ; if (label != hemi_label) continue ; label = MRIgetVoxVal(mri_aparc, xi, yi, zi,0) ; if (label && label != label0) // if outside the ribbon it won't be assigned to a parcel continue ; // constrain it to be in the same cortical parcel // search along vector connecting x0 to this point to make sure it is we don't perforate wm or leave and re-enter cortex nx = xi-x0 ; ny = yi-y0 ; nz = zi-z0 ; thickness = sqrt(nx*nx + ny*ny + nz*nz) ; assignable = 1 ; // assume this point should be counted if (thickness > 0) { nx /= thickness ; ny /= thickness ; nz /= thickness ; dot = nx*snx + ny*sny + nz*snz ; angle = acos(dot) ; if (FABS(angle) > angle_threshold) assignable = 0 ; outside_of_ribbon = 0 ; for (dist = 0 ; assignable && dist <= thickness ; dist += step_size) { xv = x0+nx*dist ; yv = y0+ny*dist ; zv = z0+nz*dist ; if (nint(xv) == Gx && nint(yv) == Gy && nint(zv) == Gz) DiagBreak() ; MRIsampleVolume(mri_pial_dist, xv, yv, zv, &pdist) ; MRIsampleVolume(mri_white_dist, xv, yv, zv, &wdist) ; label = MRIgetVoxVal(mri_aseg, xi, yi, zi,0) ; if (SKIP_LABEL(label) || label == ohemi_label) assignable = 0 ; if (wdist < 0) // entered wm - not assignable assignable = 0 ; else { if (pdist > 0) // outside pial surface outside_of_ribbon = 1 ; else { if (outside_of_ribbon) // left ribbon and reentered assignable = 0 ; } } } } // close of thickness > 0 if (assignable) ngm++ ; else DiagBreak() ; } } } MRIsetVoxVal(mri_features, vno, 0, 0, 0, ngm) ; } MRIfree(&mri_white_dist) ; MRIfree(&mri_pial_dist) ; MRIfree(&mri_binary) ; return(mri_features) ; }
static MRI * MRIcomputeSurfaceDistanceProbabilities(MRI_SURFACE *mris, MRI *mri_ribbon, MRI *mri, MRI *mri_aseg) { MRI *mri_features, *mri_binary, *mri_white_dist, *mri_pial_dist, *mri_mask ; int nwhite_bins, npial_bins, x, y, z, label, i ; HISTOGRAM2D *hw, *hp ; float pdist, wdist, val ; double wval, pval ; mri_features = MRIallocSequence(mri->width, mri->height, mri->depth, MRI_FLOAT, 2) ; MRIcopyHeader(mri, mri_features) ; mri_binary = MRIcopy(mri_ribbon, NULL) ; mri_binary = MRIbinarize(mri_ribbon, NULL, 1, 0, 1) ; mri_pial_dist = MRIdistanceTransform(mri_binary, NULL, 1, max_pial_dist+1, DTRANS_MODE_SIGNED,NULL); if (Gdiag & DIAG_WRITE && DIAG_VERBOSE_ON) MRIwrite(mri_pial_dist, "pd.mgz") ; MRIclear(mri_binary) ; MRIcopyLabel(mri_ribbon, mri_binary, Left_Cerebral_White_Matter) ; MRIcopyLabel(mri_ribbon, mri_binary, Right_Cerebral_White_Matter) ; MRIbinarize(mri_binary, mri_binary, 1, 0, 1) ; mri_white_dist = MRIdistanceTransform(mri_binary, NULL, 1, max_white_dist+1, DTRANS_MODE_SIGNED,NULL); if (Gdiag & DIAG_WRITE && DIAG_VERBOSE_ON) MRIwrite(mri_white_dist, "wd.mgz") ; nwhite_bins = ceil((max_white_dist - min_white_dist) / white_bin_size)+1 ; npial_bins = ceil((max_pial_dist - min_pial_dist) / pial_bin_size)+1 ; hw = HISTO2Dalloc(NBINS, nwhite_bins) ; hp = HISTO2Dalloc(NBINS, npial_bins) ; HISTO2Dinit(hw, NBINS, nwhite_bins, 0, NBINS-1, min_white_dist, max_white_dist) ; HISTO2Dinit(hp, NBINS, npial_bins, 0, NBINS-1, min_pial_dist, max_pial_dist) ; for (x = 0 ; x < mri->width ; x++) for (y = 0 ; y < mri->height ; y++) for (z = 0 ; z < mri->depth ; z++) { label = MRIgetVoxVal(mri_aseg, x, y, z, 0) ; if (IS_CEREBELLUM(label) || IS_VENTRICLE(label) || label == Brain_Stem || IS_CC(label)) continue ; pdist = MRIgetVoxVal(mri_pial_dist, x, y, z, 0) ; wdist = MRIgetVoxVal(mri_pial_dist, x, y, z, 0) ; val = MRIgetVoxVal(mri, x, y, z, 0) ; if (pdist >= min_pial_dist && pdist <= max_pial_dist) HISTO2DaddSample(hp, val, pdist, 0, 0, 0, 0) ; if (wdist >= min_white_dist && wdist <= max_white_dist) HISTO2DaddSample(hw, val, wdist, 0, 0, 0, 0) ; } HISTO2DmakePDF(hp, hp) ; HISTO2DmakePDF(hw, hw) ; for (x = 0 ; x < mri->width ; x++) for (y = 0 ; y < mri->height ; y++) for (z = 0 ; z < mri->depth ; z++) { label = MRIgetVoxVal(mri_aseg, x, y, z, 0) ; if (IS_CEREBELLUM(label) || IS_VENTRICLE(label) || label == Brain_Stem || IS_CC(label)) continue ; pdist = MRIgetVoxVal(mri_pial_dist, x, y, z, 0) ; wdist = MRIgetVoxVal(mri_pial_dist, x, y, z, 0) ; val = MRIgetVoxVal(mri, x, y, z, 0) ; wval = HISTO2DgetCount(hw, val, wdist); if (DZERO(wval) == 0) MRIsetVoxVal(mri_features, x, y, z, 1, -log10(wval)) ; pval = HISTO2DgetCount(hp, val, pdist); if (DZERO(pval) == 0) MRIsetVoxVal(mri_features, x, y, z, 0, -log10(pval)) ; } MRIclear(mri_binary) ; MRIbinarize(mri_ribbon, mri_binary, 1, 0, 1) ; mri_mask = MRIcopy(mri_binary, NULL) ; for (i = 0 ; i < close_order ; i++) { MRIdilate(mri_binary, mri_mask) ; MRIcopy(mri_mask, mri_binary) ; } for (i = 0 ; i < close_order ; i++) { MRIerode(mri_binary, mri_mask) ; MRIcopy(mri_mask, mri_binary) ; } MRIwrite(mri_mask, "m.mgz") ; MRImask(mri_features, mri_mask, mri_features, 0, 0) ; HISTO2Dfree(&hw) ; HISTO2Dfree(&hp) ; MRIfree(&mri_white_dist) ; MRIfree(&mri_pial_dist) ; MRIfree(&mri_binary) ; return(mri_features) ; }
static MRI * MRIremoveWMOutliersAndRetainMedialSurface(MRI *mri_src, MRI *mri_src_ctrl, MRI *mri_dst_ctrl, int intensity_below) { MRI *mri_bin, *mri_dist, *mri_dist_sup, *mri_outliers = NULL ; float max, thresh, val; HISTOGRAM *histo, *hsmooth ; int wm_peak, x, y, z, nremoved = 0, whalf = 5 ; if (Gdiag & DIAG_WRITE && DIAG_VERBOSE_ON) { MRIwrite(mri_src_ctrl, "sc.mgz") ; } mri_bin = MRIbinarize(mri_dst_ctrl, NULL, 1, 0, 1) ; mri_dist = MRIdistanceTransform(mri_bin, NULL, 1, -1, DTRANS_MODE_SIGNED, NULL); MRIscalarMul(mri_dist, mri_dist, -1) ; mri_dist_sup = MRInonMaxSuppress(mri_dist, NULL, 0, 1) ; mri_dst_ctrl = MRIbinarize(mri_dist_sup, mri_dst_ctrl, 1, 0, 1) ; histo = MRIhistogramLabel(mri_src, mri_src_ctrl, 1, 256) ; hsmooth = HISTOcopy(histo, NULL) ; HISTOsmooth(histo, hsmooth, 2) ; if (Gdiag & DIAG_WRITE && DIAG_VERBOSE_ON) { HISTOplot(histo, "h.plt") ; HISTOplot(hsmooth, "hs.plt") ; } wm_peak = HISTOfindHighestPeakInRegion(hsmooth, 1, hsmooth->nbins-1) ; wm_peak = hsmooth->bins[wm_peak] ; thresh = wm_peak-intensity_below ; HISTOfree(&histo) ; HISTOfree(&hsmooth) ; if (Gdiag & DIAG_WRITE) { mri_outliers = MRIclone(mri_dst_ctrl, 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 (x == Gx && y == Gy && z == Gz) { DiagBreak() ; } if (nint(MRIgetVoxVal(mri_dst_ctrl, x, y, z, 0)) == 0) { continue ; } max = MRImaxInLabelInRegion(mri_src, mri_dst_ctrl, 1, x, y, z, whalf); val = MRIgetVoxVal(mri_src, x, y, z, 0) ; if (val+intensity_below < max && val < thresh) { MRIsetVoxVal(mri_dst_ctrl, x, y, z, 0, 0) ; if (mri_outliers) { MRIsetVoxVal(mri_outliers, x, y, z, 0, 128) ; } nremoved++ ; } } } } printf( "%d control points removed\n", nremoved) ; if (mri_outliers) { printf( "writing out.mgz outlier volume\n") ; MRIwrite(mri_outliers, "out.mgz") ; MRIfree(&mri_outliers) ; } if (Gdiag & DIAG_WRITE && DIAG_VERBOSE_ON) { MRIwrite(mri_dst_ctrl, "dc.mgz") ; } MRIfree(&mri_bin) ; MRIfree(&mri_dist); MRIfree(&mri_dist_sup); return(mri_dst_ctrl); }
static int MRISrepositionToInnerSkull(MRI_SURFACE *mris, MRI *mri_smooth, INTEGRATION_PARMS *parms) { MRI *mri_dist, *mri_bin, *mri_kernel, *mri_bin_smooth, *mri_dist_smooth ; float l_spring, sigma ; int i, ic_order, avgs ; parms->niterations = 1000 ; if (parms->momentum < 0.0) parms->momentum = 0.0 /*0.75*/ ; mri_bin = MRIbinarize(mri_smooth, NULL, 15, 0, TARGET_VAL) ; mri_dist = MRIdistanceTransform(mri_bin, NULL, TARGET_VAL, 10*mri_bin->width, DTRANS_MODE_SIGNED, NULL) ; MRIwrite(mri_bin, "bin.mgz") ; MRIwrite(mri_dist, "dist.mgz") ; MRISscaleBrain(mris, mris, 0.5) ; // start inside mri_kernel = MRIgaussian1d(2, 0) ; mri_bin_smooth = MRIconvolveGaussian(mri_bin, NULL, mri_kernel) ; MRIwrite(mri_bin_smooth, "bin_smooth.mgz") ; MRISfindOptimalRigidPosition(mris, mri_bin_smooth, parms) ; MRIfree(&mri_kernel) ; MRIfree(&mri_bin_smooth) ; avgs = parms->n_averages = 32 ; l_spring = parms->l_spring_norm ; for (ic_order = 3 ; ic_order <= 3 ; ic_order++) { if (ic_order != ic_init) { MRI_SURFACE *mris_new ; char fname[STRLEN], *mdir ; mdir = getenv("FREESURFER_HOME") ; if (!mdir) ErrorExit(ERROR_BADPARM, "FREESURFER_HOME not defined in environment") ; sprintf(fname, "%s/lib/bem/ic%d.tri", mdir, ic_order) ; mris_new = MRISread(fname) ; MRISupsampleIco(mris, mris_new) ; MRISfree(&mris) ; mris = mris_new ; } printf("********************** using ICO order %d *********************\n", ic_order) ; parms->n_averages = avgs ; parms->l_spring_norm = l_spring ; for (sigma = 16.0, i = 0 ; i < 7 ; i++, sigma /= 2) { printf("******************** pass %d, sigma = %2.2f, avgs = %d ******************\n", i+1, sigma, parms->n_averages) ; parms->sigma = sigma ; MRISsetVals(mris,parms->sigma) ; MRIScopyValToVal2(mris) ; MRISsetVals(mris, 0) ; // 0 mm from fat parms->mri_brain = mri_dist ; mri_kernel = MRIgaussian1d(sigma, 0) ; mri_dist_smooth = MRIconvolveGaussian(mri_dist, NULL, mri_kernel) ; MRIfree(&mri_kernel) ; if (i == 0) { MRIwrite(mri_dist_smooth, "dist_smooth.mgz") ; MRISwrite(mris, "lh.0000") ; } MRISsetVals(mris, 0) ; MRISpositionSurface(mris, mri_dist, mri_dist_smooth, parms) ; parms->l_spring_norm /= 2; parms->n_averages /= 2 ; } } MRIfree(&mri_bin) ; MRIfree(&mri_dist) ; return(NO_ERROR) ; }
int main(int argc, char *argv[]) { char **av, fname[STRLEN], *T1_fname, *PD_fname, *output_dir, *mdir ; int ac, nargs, msec, s ; MRI_SURFACE *mris ; MRI *mri_flash1, *mri_flash2, *mri_masked, *mri_masked_smooth, *mri_kernel, *mri_mean, *mri_dif, *mri_binary, *mri_distance ; MRI *mri_smooth, *mri_grad, *mri_inner ; struct timeb then ; double l_spring ; MRI_SEGMENTATION *mriseg ; /* rkt: check for and handle version tag */ nargs = handle_version_option (argc, argv, "$Id: mris_AA_shrinkwrap.c,v 1.5 2011/03/02 00:04:34 nicks Exp $", "$Name: stable5 $"); if (nargs && argc - nargs == 1) exit (0); argc -= nargs; Gdiag |= DIAG_SHOW ; Progname = argv[0] ; ErrorInit(NULL, NULL, NULL) ; DiagInit(NULL, NULL, NULL) ; memset(&parms, 0, sizeof(parms)) ; parms.projection = NO_PROJECTION ; parms.tol = 0.05 ; parms.check_tol = 1 ; parms.ignore_energy = 1 ; parms.dt = 0.5f ; parms.base_dt = BASE_DT_SCALE*parms.dt ; parms.l_spring_norm = 1 ; parms.l_shrinkwrap = 0 ; parms.l_intensity = 1 ; parms.niterations = 0 ; parms.write_iterations = 0 /*WRITE_ITERATIONS */; parms.integration_type = INTEGRATE_MOMENTUM ; parms.momentum = 0.0 /*0.8*/ ; parms.l_intensity = 1 ; parms.dt_increase = 1.0 /* DT_INCREASE */; parms.dt_decrease = 0.50 /* DT_DECREASE*/ ; parms.error_ratio = 50.0 /*ERROR_RATIO */; /* parms.integration_type = INTEGRATE_LINE_MINIMIZE ;*/ parms.l_surf_repulse = 0.0 ; parms.l_repulse = 0 /*1*/ ; ac = argc ; av = argv ; for ( ; argc > 1 && ISOPTION(*argv[1]) ; argc--, argv++) { nargs = get_option(argc, argv) ; argc -= nargs ; argv += nargs ; } mdir = getenv("FREESURFER_HOME") ; if (!mdir) ErrorExit(ERROR_BADPARM, "FREESURFER_HOME not defined in environment") ; if (argc < 4) usage_exit() ; /* set default parameters for white and gray matter surfaces */ parms.niterations = 1000 ; if (parms.momentum < 0.0) parms.momentum = 0.0 /*0.75*/ ; TimerStart(&then) ; T1_fname = argv[1] ; PD_fname = argv[2] ; output_dir = argv[3] ; fprintf(stderr, "reading volume %s...\n", T1_fname) ; mri_flash1 = MRIread(T1_fname) ; if (!mri_flash1) ErrorExit(ERROR_NOFILE, "%s: could not read input volume %s", Progname, T1_fname) ; mri_flash2 = MRIread(PD_fname) ; if (!mri_flash2) ErrorExit(ERROR_NOFILE, "%s: could not read input volume %s", Progname, T1_fname) ; // setMRIforSurface(mri_flash1); sprintf(fname, "%s/lib/bem/ic%d.tri", mdir, ic_init) ; mris = MRISread(fname) ; if (!mris) ErrorExit(ERROR_NOFILE, "%s: could not read icosahedron %s", Progname, fname) ; mri_mean = MRImean(mri_flash1, NULL, 5) ; MRIwrite(mri_mean, "mean.mgz") ; mri_dif = MRIabsdiff(mri_flash1, mri_flash2, NULL) ; MRIwrite(mri_dif, "dif.mgz") ; mriseg = MRIsegment(mri_mean, 30, 100000) ; s = MRIsegmentMax(mriseg) ; mri_masked = MRIsegmentToImage(mri_flash1, NULL, mriseg, s) ; MRIwrite(mri_masked, "mask.mgz") ; MRIsegmentFree(&mriseg) ; // MRIthresholdMask(mri_dif, mri_masked, mri_dif, 1, 0) ; // MRIwrite(mri_dif, "dif_masked.mgz") ; mri_kernel = MRIgaussian1d(2, 0) ; mri_smooth = MRIconvolveGaussian(mri_dif, NULL, mri_kernel) ; MRIwrite(mri_smooth, "smooth.mgz") ; MRIScopyVolGeomFromMRI(mris, mri_smooth) ; mris->useRealRAS = 1 ; initialize_surface_position(mris, mri_dif, 1, &parms) ; MRISwrite(mris, "init") ; MRISrepositionToInnerSkull(mris, mri_smooth, &parms) ; exit(0) ; mri_grad = MRIsobel(mri_smooth, NULL, NULL) ; MRIwrite(mri_grad, "grad.mgz") ; mri_inner = MRIfindInnerBoundary(mri_dif, mri_grad, NULL, 5.0) ; MRIwrite(mri_inner, "inner.mgz") ; MRIbinarize(mri_inner, mri_inner, 10, 0, 128) ; MRISpositionOptimalSphere(mris, mri_inner, 6) ; MRISwrite(mris, "optimal") ; exit(0) ; parms.sigma = 4 / mri_flash1->xsize ; // mri_dist = create_distance_map(mri_masked, NULL, BORDER_VAL, OUTSIDE_BORDER_STEP) ; MRISsetVals(mris,parms.sigma) ; MRIScopyValToVal2(mris) ; MRISsetVals(mris, 0) ; sprintf(parms.base_name, "%s_inner_skull%s%s", "test", output_suffix, suffix) ; parms.mri_brain = mri_masked ; l_spring = parms.l_spring_norm ; mri_kernel = MRIgaussian1d(parms.sigma, 0) ; mri_binary = MRIbinarize(mri_dif, mri_binary, 40, 0, 128) ; MRIwrite(mri_binary, "bin.mgz") ; mri_distance = MRIdistanceTransform(mri_binary, NULL, 128, 100, DTRANS_MODE_SIGNED, NULL) ; MRIwrite(mri_distance, "dist.mgz") ; mri_masked_smooth = MRIconvolveGaussian(mri_distance, NULL, mri_kernel) ; MRIfree(&mri_kernel) ; MRIwrite(mri_masked_smooth, "dif_smooth.mgz") ; MRISwrite(mris, "inner_skull.tri") ; msec = TimerStop(&then) ; fprintf(stderr,"positioning took %2.1f minutes\n", (float)msec/(60*1000.0f)); exit(0) ; return(0) ; /* for ansi */ }
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) ; }