static int normalize_timepoints_with_samples(MRI *mri, GCA_SAMPLE *gcas, int nsamples, int nsoap) { int frame, i, x, y, z ; double target, val ; MRI *mri_ctrl, *mri_bias, *mri_target, *mri_frame ; mri_ctrl = MRIcloneDifferentType(mri, MRI_UCHAR) ; mri_bias = MRIcloneDifferentType(mri, MRI_FLOAT) ; mri_target = MRIcloneDifferentType(mri, MRI_FLOAT) ; for (i = 0 ; i < nsamples ; i++) { if (i == Gdiag_no) DiagBreak() ; x = nint(gcas[i].x) ; y = nint(gcas[i].y) ; z = nint(gcas[i].z) ; MRIsetVoxVal(mri_ctrl, x, y, z, 0, CONTROL_MARKED) ; for (target = 0.0, frame = 0 ; frame < mri->nframes ; frame++) target += MRIgetVoxVal(mri, x, y, z, frame) ; target /= mri->nframes ; MRIsetVoxVal(mri_target, x, y, z, 0, target) ; } // build a bias correction for each time point (which each has its own frame) for (frame = 0 ; frame < mri->nframes ; frame++) { MRIclear(mri_bias) ; for (i = 0 ; i < nsamples ; i++) { if (i == Gdiag_no) DiagBreak() ; x = nint(gcas[i].x) ; y = nint(gcas[i].y) ; z = nint(gcas[i].z) ; target = MRIgetVoxVal(mri_target, x, y, z, 0) ; val = MRIgetVoxVal(mri, x, y, z, frame) ; if (FZERO(val)) val = 1.0 ; MRIsetVoxVal(mri_bias, x, y, z, 0, target/val) ; } MRIbuildVoronoiDiagram(mri_bias, mri_ctrl, mri_bias) ; MRIsoapBubble(mri_bias, mri_ctrl, mri_bias, nsoap) ; mri_frame = MRIcopyFrame(mri, NULL, frame, 0) ; MRImultiply(mri_frame, mri_bias, mri_frame) ; if (Gdiag & DIAG_WRITE && DIAG_VERBOSE_ON) { char fname[STRLEN] ; sprintf(fname, "frame%d.mgz", frame) ; MRIwrite(mri_frame, fname) ; sprintf(fname, "bias%d.mgz", frame) ; MRIwrite(mri_bias, fname) ; sprintf(fname, "target%d.mgz", frame) ; MRIwrite(mri_target, fname) ; } MRIcopyFrame(mri_frame, mri, 0, frame) ; } MRIfree(&mri_bias) ; MRIfree(&mri_target) ; MRIfree(&mri_ctrl) ; return(NO_ERROR) ; }
static int normalize_timepoints(MRI *mri, double thresh, double cross_time_sigma) { int frame, x, y, z, skip, nvox ; double target, val ; MRI *mri_ctrl, *mri_bias, *mri_target, *mri_frame, *mri_kernel ; mri_ctrl = MRIcloneDifferentType(mri, MRI_UCHAR) ; mri_bias = MRIcloneDifferentType(mri, MRI_FLOAT) ; mri_target = MRIcloneDifferentType(mri, MRI_FLOAT) ; mri_kernel = MRIgaussian1d(cross_time_sigma, -1) ; for (nvox = x = 0 ; x < mri->width ; x++) for (y = 0 ; y < mri->height ; y++) for (z = 0 ; z < mri->depth ; z++) { if (x == Gx && y == Gy && z == Gz) DiagBreak() ; for (target = 0.0, frame = 0 ; frame < mri->nframes ; frame++) target += MRIgetVoxVal(mri, x, y, z, frame) ; target /= mri->nframes ; if (FZERO(target)) continue ; // both vals 0 skip = 0 ; for (frame = 0 ; frame < mri->nframes ; frame++) { val = MRIgetVoxVal(mri, x, y, z, frame) ; if (fabs(val-target) > thresh) { skip = 1 ; break ; } } if (skip) continue ; nvox++ ; MRIsetVoxVal(mri_ctrl, x, y, z, 0, CONTROL_MARKED) ; MRIsetVoxVal(mri_target, x, y, z, 0, target) ; } printf("%d voxels found to base intensity correction on\n", nvox) ; // build a bias correction for each time point (which each has its own frame) for (frame = 0 ; frame < mri->nframes ; frame++) { MRIclear(mri_bias) ; for (x = 0 ; x < mri->width ; x++) for (y = 0 ; y < mri->height ; y++) for (z = 0 ; z < mri->depth ; z++) { target = MRIgetVoxVal(mri_target, x, y, z, 0) ; val = MRIgetVoxVal(mri, x, y, z, frame) ; if (FZERO(val)) val = 1.0 ; MRIsetVoxVal(mri_bias, x, y, z, 0, target/val) ; } MRIbuildVoronoiDiagram(mri_bias, mri_ctrl, mri_bias) ; MRIconvolveGaussian(mri_bias, mri_bias, mri_kernel) ; // MRIsoapBubble(mri_bias, mri_ctrl, mri_bias, nsoap) ; mri_frame = MRIcopyFrame(mri, NULL, frame, 0) ; MRImultiply(mri_frame, mri_bias, mri_frame) ; if (Gdiag & DIAG_WRITE && DIAG_VERBOSE_ON) { char fname[STRLEN] ; sprintf(fname, "frame%d.mgz", frame) ; MRIwrite(mri_frame, fname) ; sprintf(fname, "bias%d.mgz", frame) ; MRIwrite(mri_bias, fname) ; sprintf(fname, "target%d.mgz", frame) ; MRIwrite(mri_target, fname) ; } MRIcopyFrame(mri_frame, mri, 0, frame) ; } MRIfree(&mri_bias) ; MRIfree(&mri_kernel) ; MRIfree(&mri_target) ; MRIfree(&mri_ctrl) ; return(NO_ERROR) ; }
int main(int argc, char *argv[]) { char **av ; int ac, nargs, n ; MRI *mri_src, *mri_dst = NULL, *mri_bias, *mri_orig, *mri_aseg = NULL ; char *in_fname, *out_fname ; int msec, minutes, seconds ; struct timeb start ; char cmdline[CMD_LINE_LEN] ; make_cmd_version_string (argc, argv, "$Id: mri_normalize.c,v 1.80 2012/10/16 21:38:35 nicks Exp $", "$Name: $", cmdline); /* rkt: check for and handle version tag */ nargs = handle_version_option (argc, argv, "$Id: mri_normalize.c,v 1.80 2012/10/16 21:38:35 nicks Exp $", "$Name: $"); if (nargs && argc - nargs == 1) { exit (0); } argc -= nargs; Progname = argv[0] ; ErrorInit(NULL, NULL, NULL) ; DiagInit(NULL, NULL, NULL) ; mni.max_gradient = MAX_GRADIENT ; ac = argc ; av = argv ; for ( ; argc > 1 && ISOPTION(*argv[1]) ; argc--, argv++) { nargs = get_option(argc, argv) ; argc -= nargs ; argv += nargs ; } if (argc < 3) { usage_exit(0) ; } if (argc < 1) { ErrorExit(ERROR_BADPARM, "%s: no input name specified", Progname) ; } in_fname = argv[1] ; if (argc < 2) { ErrorExit(ERROR_BADPARM, "%s: no output name specified", Progname) ; } out_fname = argv[2] ; if(verbose) { printf( "reading from %s...\n", in_fname) ; } mri_src = MRIread(in_fname) ; if (!mri_src) ErrorExit(ERROR_NO_FILE, "%s: could not open source file %s", Progname, in_fname) ; MRIaddCommandLine(mri_src, cmdline) ; if(nsurfs > 0) { MRI_SURFACE *mris ; MRI *mri_dist=NULL, *mri_dist_sup=NULL, *mri_ctrl, *mri_dist_one ; LTA *lta= NULL ; int i ; TRANSFORM *surface_xform ; if (control_point_fname) // do one pass with only file control points first { MRI3dUseFileControlPoints(mri_src, control_point_fname) ; mri_dst = MRI3dGentleNormalize(mri_src, NULL, DEFAULT_DESIRED_WHITE_MATTER_VALUE, NULL, intensity_above, intensity_below/2,1, bias_sigma, mri_not_control); } else { mri_dst = MRIcopy(mri_src, NULL) ; } for (i = 0 ; i < nsurfs ; i++) { mris = MRISread(surface_fnames[i]) ; if (mris == NULL) ErrorExit(ERROR_NOFILE,"%s: could not surface %s", Progname,surface_fnames[i]); surface_xform = surface_xforms[i] ; TransformInvert(surface_xform, NULL) ; if (surface_xform->type == MNI_TRANSFORM_TYPE || surface_xform->type == TRANSFORM_ARRAY_TYPE || surface_xform->type == REGISTER_DAT) { lta = (LTA *)(surface_xform->xform) ; #if 0 if (invert) { VOL_GEOM vgtmp; LT *lt; MATRIX *m_tmp = lta->xforms[0].m_L ; lta->xforms[0].m_L = MatrixInverse(lta->xforms[0].m_L, NULL) ; MatrixFree(&m_tmp) ; lt = <a->xforms[0]; if (lt->dst.valid == 0 || lt->src.valid == 0) { printf( "WARNING:***************************************************************\n"); printf( "WARNING:dst volume infor is invalid. Most likely produce wrong inverse.\n"); printf( "WARNING:***************************************************************\n"); } copyVolGeom(<->dst, &vgtmp); copyVolGeom(<->src, <->dst); copyVolGeom(&vgtmp, <->src); } #endif } if (stricmp(surface_xform_fnames[i], "identity.nofile") != 0) { MRIStransform(mris, NULL, surface_xform, NULL) ; } mri_dist_one = MRIcloneDifferentType(mri_dst, MRI_FLOAT) ; printf("computing distance transform\n") ; MRIScomputeDistanceToSurface(mris, mri_dist_one, mri_dist_one->xsize) ; if (i == 0) { mri_dist = MRIcopy(mri_dist_one, NULL) ; } else { MRIcombineDistanceTransforms(mri_dist_one, mri_dist, mri_dist) ; } // MRIminAbs(mri_dist_one, mri_dist, mri_dist) ; MRIfree(&mri_dist_one) ; } MRIscalarMul(mri_dist, mri_dist, -1) ; if (nonmax_suppress) { printf("computing nonmaximum suppression\n") ; mri_dist_sup = MRInonMaxSuppress(mri_dist, NULL, 0, 1) ; mri_ctrl = MRIcloneDifferentType(mri_dist_sup, MRI_UCHAR) ; MRIbinarize(mri_dist_sup, mri_ctrl, min_dist, CONTROL_NONE, CONTROL_MARKED) ; } else if (erode) { int i ; mri_ctrl = MRIcloneDifferentType(mri_dist, MRI_UCHAR) ; MRIbinarize(mri_dist, mri_ctrl, min_dist, CONTROL_NONE, CONTROL_MARKED) ; for (i = 0 ; i < erode ; i++) { MRIerode(mri_ctrl, mri_ctrl) ; } } else { mri_ctrl = MRIcloneDifferentType(mri_dist, MRI_UCHAR) ; MRIbinarize(mri_dist, mri_ctrl, min_dist, CONTROL_NONE, CONTROL_MARKED) ; } if (control_point_fname) { MRInormAddFileControlPoints(mri_ctrl, CONTROL_MARKED) ; } if (mask_sigma > 0) { MRI *mri_smooth, *mri_mag, *mri_grad ; mri_smooth = MRIgaussianSmooth(mri_dst, mask_sigma, 1, NULL) ; mri_mag = MRIcloneDifferentType(mri_dst, MRI_FLOAT) ; mri_grad = MRIsobel(mri_smooth, NULL, mri_mag) ; MRIbinarize(mri_mag, mri_mag, mask_thresh, 1, 0) ; MRImask(mri_ctrl, mri_mag, mri_ctrl, 0, CONTROL_NONE) ; MRIfree(&mri_grad) ; MRIfree(&mri_mag) ; MRIfree(&mri_smooth) ; } if (mask_orig_fname) { MRI *mri_orig ; mri_orig = MRIread(mask_orig_fname) ; MRIbinarize(mri_orig, mri_orig, mask_orig_thresh, 0, 1) ; MRImask(mri_ctrl, mri_orig, mri_ctrl, 0, CONTROL_NONE) ; MRIfree(&mri_orig) ; } if (Gdiag & DIAG_WRITE && DIAG_VERBOSE_ON) { MRIwrite(mri_dist, "d.mgz"); MRIwrite(mri_dist_sup, "dm.mgz"); MRIwrite(mri_ctrl, "c.mgz"); } MRIeraseBorderPlanes(mri_ctrl, 4) ; if (aseg_fname) { mri_aseg = MRIread(aseg_fname) ; if (mri_aseg == NULL) { ErrorExit(ERROR_NOFILE, "%s: could not load aseg from %s", Progname, aseg_fname) ; } remove_nonwm_voxels(mri_ctrl, mri_aseg, mri_ctrl) ; MRIfree(&mri_aseg) ; } else { remove_surface_outliers(mri_ctrl, mri_dist, mri_dst, mri_ctrl) ; } mri_bias = MRIbuildBiasImage(mri_dst, mri_ctrl, NULL, 0.0) ; if (mri_dist) { MRIfree(&mri_dist) ; } if (mri_dist_sup) { MRIfree(&mri_dist_sup) ; } if (bias_sigma> 0) { MRI *mri_kernel = MRIgaussian1d(bias_sigma, -1) ; if (Gdiag & DIAG_WRITE && DIAG_VERBOSE_ON) { MRIwrite(mri_bias, "b.mgz") ; } printf("smoothing bias field\n") ; MRIconvolveGaussian(mri_bias, mri_bias, mri_kernel) ; if (Gdiag & DIAG_WRITE && DIAG_VERBOSE_ON) { MRIwrite(mri_bias, "bs.mgz") ; } MRIfree(&mri_kernel); } MRIfree(&mri_ctrl) ; mri_dst = MRIapplyBiasCorrectionSameGeometry (mri_dst, mri_bias, mri_dst, DEFAULT_DESIRED_WHITE_MATTER_VALUE) ; printf("writing normalized volume to %s\n", out_fname) ; MRIwrite(mri_dst, out_fname) ; exit(0) ; } // end if(surface_fname) if (!mriConformed(mri_src) && conform > 0) { printf("unconformed source detected - conforming...\n") ; mri_src = MRIconform(mri_src) ; } if (mask_fname) { MRI *mri_mask ; mri_mask = MRIread(mask_fname) ; if (!mri_mask) ErrorExit(ERROR_NOFILE, "%s: could not open mask volume %s.\n", Progname, mask_fname) ; MRImask(mri_src, mri_mask, mri_src, 0, 0) ; MRIfree(&mri_mask) ; } if (read_flag) { MRI *mri_ctrl ; double scale ; mri_bias = MRIread(bias_volume_fname) ; if (!mri_bias) ErrorExit (ERROR_BADPARM, "%s: could not read bias volume %s", Progname, bias_volume_fname) ; mri_ctrl = MRIread(control_volume_fname) ; if (!mri_ctrl) ErrorExit (ERROR_BADPARM, "%s: could not read control volume %s", Progname, control_volume_fname) ; MRIbinarize(mri_ctrl, mri_ctrl, 1, 0, 128) ; mri_dst = MRImultiply(mri_bias, mri_src, NULL) ; scale = MRImeanInLabel(mri_dst, mri_ctrl, 128) ; printf("mean in wm is %2.0f, scaling by %2.2f\n", scale, 110/scale) ; scale = 110/scale ; MRIscalarMul(mri_dst, mri_dst, scale) ; MRIwrite(mri_dst, out_fname) ; exit(0) ; } if(long_flag) { MRI *mri_ctrl ; double scale ; mri_bias = MRIread(long_bias_volume_fname) ; if (!mri_bias) ErrorExit (ERROR_BADPARM, "%s: could not read bias volume %s", Progname, long_bias_volume_fname) ; mri_ctrl = MRIread(long_control_volume_fname) ; if (!mri_ctrl) ErrorExit (ERROR_BADPARM, "%s: could not read control volume %s", Progname, long_control_volume_fname) ; MRIbinarize(mri_ctrl, mri_ctrl, 1, 0, CONTROL_MARKED) ; if (mri_ctrl->type != MRI_UCHAR) { MRI *mri_tmp ; mri_tmp = MRIchangeType(mri_ctrl, MRI_UCHAR, 0, 1,1); MRIfree(&mri_ctrl) ; mri_ctrl = mri_tmp ; } scale = MRImeanInLabel(mri_src, mri_ctrl, CONTROL_MARKED) ; printf("mean in wm is %2.0f, scaling by %2.2f\n", scale, 110/scale) ; scale = DEFAULT_DESIRED_WHITE_MATTER_VALUE/scale ; mri_dst = MRIscalarMul(mri_src, NULL, scale) ; MRIremoveWMOutliers(mri_dst, mri_ctrl, mri_ctrl, intensity_below/2) ; mri_bias = MRIbuildBiasImage(mri_dst, mri_ctrl, NULL, 0.0) ; MRIsoapBubble(mri_bias, mri_ctrl, mri_bias, 50, 1) ; MRIapplyBiasCorrectionSameGeometry(mri_dst, mri_bias, mri_dst, DEFAULT_DESIRED_WHITE_MATTER_VALUE); // MRIwrite(mri_dst, out_fname) ; // exit(0) ; } // end if(long_flag) if (grad_thresh > 0) { float thresh ; MRI *mri_mag, *mri_grad, *mri_smooth ; MRI *mri_kernel = MRIgaussian1d(.5, -1) ; mri_not_control = MRIcloneDifferentType(mri_src, MRI_UCHAR) ; switch (scan_type) { case MRI_MGH_MPRAGE: thresh = 15 ; break ; case MRI_WASHU_MPRAGE: thresh = 20 ; break ; case MRI_UNKNOWN: default: thresh = 12 ; break ; } mri_smooth = MRIconvolveGaussian(mri_src, NULL, mri_kernel) ; thresh = grad_thresh ; mri_mag = MRIcloneDifferentType(mri_src, MRI_FLOAT) ; mri_grad = MRIsobel(mri_smooth, NULL, mri_mag) ; MRIwrite(mri_mag, "m.mgz") ; MRIbinarize(mri_mag, mri_not_control, thresh, 0, 1) ; MRIwrite(mri_not_control, "nc.mgz") ; MRIfree(&mri_mag) ; MRIfree(&mri_grad) ; MRIfree(&mri_smooth) ; MRIfree(&mri_kernel) ; } #if 0 #if 0 if ((mri_src->type != MRI_UCHAR) || (!(mri_src->xsize == 1 && mri_src->ysize == 1 && mri_src->zsize == 1))) #else if (conform || (mri_src->type != MRI_UCHAR && conform > 0)) #endif { MRI *mri_tmp ; fprintf (stderr, "downsampling to 8 bits and scaling to isotropic voxels...\n") ; mri_tmp = MRIconform(mri_src) ; mri_src = mri_tmp ; } #endif if(aseg_fname) { printf("Reading aseg %s\n",aseg_fname); mri_aseg = MRIread(aseg_fname) ; if (mri_aseg == NULL) ErrorExit (ERROR_NOFILE, "%s: could not read aseg from file %s", Progname, aseg_fname) ; if (!mriConformed(mri_aseg)) { ErrorExit(ERROR_UNSUPPORTED, "%s: aseg volume %s must be conformed", Progname, aseg_fname) ; } } else { mri_aseg = NULL ; } if(verbose) { printf( "normalizing image...\n") ; } fflush(stdout); fflush(stderr); TimerStart(&start) ; if (control_point_fname) { MRI3dUseFileControlPoints(mri_src, control_point_fname) ; } // this just setup writing control-point volume saving if(control_volume_fname) { MRI3dWriteControlPoints(control_volume_fname) ; } /* first do a gentle normalization to get things in the right intensity range */ if(long_flag == 0) // if long, then this will already have been done with base control points { if(control_point_fname != NULL) /* do one pass with only file control points first */ mri_dst = MRI3dGentleNormalize(mri_src, NULL, DEFAULT_DESIRED_WHITE_MATTER_VALUE, NULL, intensity_above, intensity_below/2,1, bias_sigma, mri_not_control); else { mri_dst = MRIcopy(mri_src, NULL) ; } } fflush(stdout); fflush(stderr); if(mri_aseg) { MRI *mri_ctrl, *mri_bias ; int i ; printf("processing with aseg\n"); mri_ctrl = MRIclone(mri_aseg, NULL) ; for (i = 0 ; i < NWM_LABELS ; i++) { MRIcopyLabel(mri_aseg, mri_ctrl, aseg_wm_labels[i]) ; } printf("removing outliers in the aseg WM...\n") ; MRIremoveWMOutliersAndRetainMedialSurface(mri_dst, mri_ctrl, mri_ctrl, intensity_below) ; MRIbinarize(mri_ctrl, mri_ctrl, 1, CONTROL_NONE, CONTROL_MARKED) ; MRInormAddFileControlPoints(mri_ctrl, CONTROL_MARKED) ; if (interior_fname1) { MRIS *mris_interior1, *mris_interior2 ; mris_interior1 = MRISread(interior_fname1) ; if (mris_interior1 == NULL) ErrorExit(ERROR_NOFILE, "%s: could not read white matter surface from %s\n", Progname, interior_fname1) ; mris_interior2 = MRISread(interior_fname2) ; if (mris_interior2 == NULL) ErrorExit(ERROR_NOFILE, "%s: could not read white matter surface from %s\n", Progname, interior_fname2) ; add_interior_points(mri_ctrl, mri_dst, intensity_above, 1.25*intensity_below, mris_interior1, mris_interior2, mri_aseg, mri_ctrl) ; MRISfree(&mris_interior1) ; MRISfree(&mris_interior2) ; } if (Gdiag & DIAG_WRITE && DIAG_VERBOSE_ON) { MRIwrite(mri_ctrl, "norm_ctrl.mgz") ; } printf("Building bias image\n"); fflush(stdout); fflush(stderr); mri_bias = MRIbuildBiasImage(mri_dst, mri_ctrl, NULL, 0.0) ; fflush(stdout); fflush(stderr); if (bias_sigma> 0) { printf("Smoothing with sigma %g\n",bias_sigma); MRI *mri_kernel = MRIgaussian1d(bias_sigma, -1) ; MRIconvolveGaussian(mri_bias, mri_bias, mri_kernel) ; MRIfree(&mri_kernel); fflush(stdout); fflush(stderr); } MRIfree(&mri_ctrl) ; MRIfree(&mri_aseg) ; printf("Applying bias correction\n"); mri_dst = MRIapplyBiasCorrectionSameGeometry (mri_dst, mri_bias, mri_dst, DEFAULT_DESIRED_WHITE_MATTER_VALUE) ; if (Gdiag & DIAG_WRITE && DIAG_VERBOSE_ON) { MRIwrite(mri_dst, "norm_1.mgz") ; } fflush(stdout); fflush(stderr); } // if(mri_aseg) else { printf("processing without aseg, no1d=%d\n",no1d); if (!no1d) { printf("MRInormInit(): \n"); MRInormInit(mri_src, &mni, 0, 0, 0, 0, 0.0f) ; printf("MRInormalize(): \n"); mri_dst = MRInormalize(mri_src, NULL, &mni) ; if (!mri_dst) { no1d = 1 ; printf("1d normalization failed - trying no1d...\n") ; // ErrorExit(ERROR_BADPARM, "%s: normalization failed", Progname) ; } } if(no1d) { if ((file_only && nosnr) || ((gentle_flag != 0) && (control_point_fname != NULL))) { if (mri_dst == NULL) { mri_dst = MRIcopy(mri_src, NULL) ; } } else { if (nosnr) { if (interior_fname1) { MRIS *mris_interior1, *mris_interior2 ; MRI *mri_ctrl ; printf("computing initial normalization using surface interiors\n"); mri_ctrl = MRIcloneDifferentType(mri_src, MRI_UCHAR) ; mris_interior1 = MRISread(interior_fname1) ; if (mris_interior1 == NULL) ErrorExit(ERROR_NOFILE, "%s: could not read white matter surface from %s\n", Progname, interior_fname1) ; mris_interior2 = MRISread(interior_fname2) ; if (mris_interior2 == NULL) ErrorExit(ERROR_NOFILE, "%s: could not read white matter surface from %s\n", Progname, interior_fname2) ; add_interior_points(mri_ctrl, mri_dst, intensity_above, 1.25*intensity_below, mris_interior1, mris_interior2, mri_aseg, mri_ctrl) ; MRISfree(&mris_interior1) ; MRISfree(&mris_interior2) ; mri_bias = MRIbuildBiasImage(mri_dst, mri_ctrl, NULL, 0.0) ; if (bias_sigma> 0) { MRI *mri_kernel = MRIgaussian1d(bias_sigma, -1) ; MRIconvolveGaussian(mri_bias, mri_bias, mri_kernel) ; MRIfree(&mri_kernel); } mri_dst = MRIapplyBiasCorrectionSameGeometry (mri_src, mri_bias, mri_dst, DEFAULT_DESIRED_WHITE_MATTER_VALUE) ; MRIfree(&mri_ctrl) ; } else if (long_flag == 0) // no initial normalization specified { mri_dst = MRIcopy(mri_src, NULL) ; } } else { printf("computing initial normalization using SNR...\n") ; mri_dst = MRInormalizeHighSignalLowStd (mri_src, mri_dst, bias_sigma, DEFAULT_DESIRED_WHITE_MATTER_VALUE) ; } } if (!mri_dst) ErrorExit (ERROR_BADPARM, "%s: could not allocate volume", Progname) ; } } // else (not using aseg) fflush(stdout); fflush(stderr); if (file_only == 0) MRI3dGentleNormalize(mri_dst, NULL, DEFAULT_DESIRED_WHITE_MATTER_VALUE, mri_dst, intensity_above, intensity_below/2, file_only, bias_sigma, mri_not_control); mri_orig = MRIcopy(mri_dst, NULL) ; printf("\n"); printf("Iterating %d times\n",num_3d_iter); for (n = 0 ; n < num_3d_iter ; n++) { if(file_only) { break ; } printf( "---------------------------------\n"); printf( "3d normalization pass %d of %d\n", n+1, num_3d_iter) ; if (gentle_flag) MRI3dGentleNormalize(mri_dst, NULL, DEFAULT_DESIRED_WHITE_MATTER_VALUE, mri_dst, intensity_above/2, intensity_below/2, file_only, bias_sigma, mri_not_control); else MRI3dNormalize(mri_orig, mri_dst, DEFAULT_DESIRED_WHITE_MATTER_VALUE, mri_dst, intensity_above, intensity_below, file_only, prune, bias_sigma, scan_type, mri_not_control); } printf( "Done iterating ---------------------------------\n"); // this just setup writing control-point volume saving if(control_volume_fname) { MRI3dWriteControlPoints(control_volume_fname) ; } if(bias_volume_fname) { mri_bias = compute_bias(mri_src, mri_dst, NULL) ; printf("writing bias field to %s....\n", bias_volume_fname) ; MRIwrite(mri_bias, bias_volume_fname) ; MRIfree(&mri_bias) ; } if (verbose) { printf("writing output to %s\n", out_fname) ; } MRIwrite(mri_dst, out_fname) ; msec = TimerStop(&start) ; MRIfree(&mri_src); MRIfree(&mri_dst); seconds = nint((float)msec/1000.0f) ; minutes = seconds / 60 ; seconds = seconds % 60 ; printf( "3D bias adjustment took %d minutes and %d seconds.\n", minutes, seconds) ; exit(0) ; return(0) ; }
int main(int argc, char *argv[]) { char **av ; int ac, nargs ; MRI *mri_orig, *mri_norm, *mri_bias ; int msec, minutes, seconds ; struct timeb start ; /* rkt: check for and handle version tag */ nargs = handle_version_option (argc, argv, "$Id: mri_apply_bias.c,v 1.5 2011/03/02 00:04:13 nicks Exp $", "$Name: stable5 $"); if (nargs && argc - nargs == 1) exit (0); argc -= nargs; Progname = argv[0] ; ErrorInit(NULL, NULL, NULL) ; DiagInit(NULL, NULL, NULL) ; TimerStart(&start) ; 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) ; mri_orig = MRIread(argv[1]) ; if (mri_orig == NULL) ErrorExit(ERROR_NOFILE, "%s: could not read %s",Progname, argv[1]) ; mri_bias = MRIread(argv[2]) ; if (mri_bias == NULL) ErrorExit(ERROR_NOFILE, "%s: could not read %s",Progname, argv[2]) ; if (xform_fname) { TRANSFORM *transform ; MRI *mri ; transform = TransformRead(xform_fname) ; if (transform == NULL) ErrorExit(ERROR_NOFILE, "%s: could not load transform %s", Progname, xform_fname) ; mri = MRIcloneDifferentType(mri_orig, MRI_FLOAT) ; TransformApplyInverse(transform, mri_bias, mri) ; MRIfree(&mri_bias) ; mri_bias = mri ; } mri_norm = apply_bias(mri_orig, NULL, mri_bias); fprintf(stderr, "writing to %s...\n", argv[3]) ; MRIwrite(mri_norm, argv[3]) ; MRIfree(&mri_norm) ; msec = TimerStop(&start) ; seconds = nint((float)msec/1000.0f) ; minutes = seconds / 60 ; seconds = seconds % 60 ; fprintf(stderr, "bias correction took %d minutes and %d seconds.\n", minutes, seconds) ; exit(0) ; return(0) ; }
int MRIcomputePartialVolumeFractions(MRI *mri_src, MATRIX *m_vox2vox, MRI *mri_seg, MRI *mri_wm, MRI *mri_subcort_gm, MRI *mri_cortex, MRI *mri_csf, int wm_val, int subcort_gm_val, int cortex_val, int csf_val) { int x, y, z, xs, ys, zs, label ; VECTOR *v1, *v2 ; MRI *mri_counts ; float val, count ; MATRIX *m_inv ; m_inv = MatrixInverse(m_vox2vox, NULL) ; if (m_inv == NULL) { MatrixPrint(stdout, m_vox2vox) ; ErrorExit(ERROR_BADPARM, "MRIcomputePartialVolumeFractions: non-invertible vox2vox matrix"); } mri_counts = MRIcloneDifferentType(mri_src, MRI_INT) ; v1 = VectorAlloc(4, MATRIX_REAL) ; v2 = VectorAlloc(4, MATRIX_REAL) ; VECTOR_ELT(v1, 4) = 1.0 ; VECTOR_ELT(v2, 4) = 1.0 ; for (x = 0 ; x < mri_seg->width ; x++) { V3_X(v1) = x ; for (y = 0 ; y < mri_seg->height ; y++) { V3_Y(v1) = y ; for (z = 0 ; z < mri_seg->depth ; z++) { if (x == Gx && y == Gy && z == Gz) DiagBreak() ; V3_Z(v1) = z ; MatrixMultiply(m_vox2vox, v1, v2) ; xs = nint(V3_X(v2)) ; ys = nint(V3_Y(v2)) ; zs = nint(V3_Z(v2)) ; if (xs >= 0 && ys >= 0 && zs >= 0 && xs < mri_src->width && ys < mri_src->height && zs < mri_src->depth) { val = MRIgetVoxVal(mri_counts, xs, ys, zs, 0) ; MRIsetVoxVal(mri_counts, xs, ys, zs, 0, val+1) ; label = MRIgetVoxVal(mri_seg, x, y, z, 0) ; if (label == csf_val) { val = MRIgetVoxVal(mri_csf, xs, ys, zs, 0) ; MRIsetVoxVal(mri_csf, xs, ys, zs, 0, val+1) ; } else if (label == wm_val) { val = MRIgetVoxVal(mri_wm, xs, ys, zs, 0) ; MRIsetVoxVal(mri_wm, xs, ys, zs, 0, val+1) ; } else if (label == subcort_gm_val) { val = MRIgetVoxVal(mri_subcort_gm, xs, ys, zs, 0) ; MRIsetVoxVal(mri_subcort_gm, xs, ys, zs, 0, val+1) ; } else if (label == cortex_val) { val = MRIgetVoxVal(mri_cortex, xs, ys, zs, 0) ; MRIsetVoxVal(mri_cortex, xs, ys, zs, 0, val+1) ; } else DiagBreak() ; } } } } for (x = 0 ; x < mri_src->width ; x++) for (y = 0 ; y < mri_src->height ; y++) for (z = 0 ; z < mri_src->depth ; z++) { count = MRIgetVoxVal(mri_counts, x, y, z, 0) ; if (count >= 1) { if (x == Gx && y == Gy && z == Gz) DiagBreak() ; val = MRIgetVoxVal(mri_wm, x, y, z, 0) ; MRIsetVoxVal(mri_wm, x, y, z, 0, val/count) ; val = MRIgetVoxVal(mri_subcort_gm, x, y, z, 0) ; MRIsetVoxVal(mri_subcort_gm, x, y, z, 0, val/count) ; val = MRIgetVoxVal(mri_cortex, x, y, z, 0) ; MRIsetVoxVal(mri_cortex, x, y, z, 0, val/count) ; val = MRIgetVoxVal(mri_csf, x, y, z, 0) ; MRIsetVoxVal(mri_csf, x, y, z, 0, val/count) ; } else // sample in other direction { V3_X(v1) = x ; V3_Y(v1) = y ; V3_Z(v1) = z ; MatrixMultiply(m_inv, v1, v2) ; MatrixMultiply(m_inv, v1, v2) ; xs = nint(V3_X(v2)) ; ys = nint(V3_Y(v2)) ; zs = nint(V3_Z(v2)) ; if (xs >= 0 && ys >= 0 && zs >= 0 && xs < mri_seg->width && ys < mri_seg->height && zs < mri_seg->depth) { label = MRIgetVoxVal(mri_seg, xs, ys, zs, 0) ; if (label == csf_val) MRIsetVoxVal(mri_csf, x, y, z, 0, 1) ; else if (label == wm_val) MRIsetVoxVal(mri_wm, x, y, z, 0, 1) ; else if (label == subcort_gm_val) MRIsetVoxVal(mri_subcort_gm, x, y, z, 0, 1) ; else if (cortex_val) MRIsetVoxVal(mri_cortex, x, y, z, 0, 1) ; else DiagBreak() ; } } } VectorFree(&v1) ; VectorFree(&v2) ; MatrixFree(&m_inv) ; MRIfree(&mri_counts) ; return(NO_ERROR) ; }
static int relabel_hypointensities(MRI *mri, MRI_SURFACE *mris, int right) { int x, y, z, label, changed ; MRIS_HASH_TABLE *mht ; VERTEX *v ; float dx, dy, dz, dot, dist ; Real xw, yw, zw ; MRI *mri_dist ; mri_dist = MRIcloneDifferentType(mri, MRI_FLOAT) ; MRIScomputeDistanceToSurface(mris, mri_dist, mri_dist->xsize) ; mht = MHTfillVertexTableRes(mris,NULL, CURRENT_VERTICES, 8.0f) ; for (changed = x = 0 ; x < mri->width ; x++) { for (y = 0 ; y < mri->height ; y++) { for (z = 0 ; z < mri->depth ; z++) { if (x == Gx && y == Gy && z == Gz) { DiagBreak() ; } label = MRIgetVoxVal(mri, x, y, z, 0) ; if (label == Left_WM_hypointensities) { MRIsetVoxVal(mri, x, y, z,0, WM_hypointensities) ; } else if (label == Right_WM_hypointensities) { MRIsetVoxVal(mri, x, y, z, 0, WM_hypointensities) ; } if ((!right && (label != Left_Cerebral_Cortex)) || (right && (label != Right_Cerebral_Cortex))) { continue ; } // MRIvoxelToWorld(mri, x, y, z, &xw, &yw, &zw) ; MRIvoxelToSurfaceRAS(mri, x, y, z, &xw, &yw, &zw); v = MHTfindClosestVertexInTable(mht, mris, xw, yw, zw, 0) ; if (v == NULL) /* no vertices within range - assume it is hypointensity */ { dot = -1 ; dist = MRIgetVoxVal(mri_dist, x, y, z, 0) ; if (dist > 0) { dot = 1 ; } } else { dx = xw - v->x ; dy = yw - v->y ; dz = zw - v->z ; dot = v->nx*dx + v->ny*dy + v->nz*dz ; dist = sqrt(dx*dx+dy*dy+dz*dz) ; } if (dot < 0 && dist > 1) { changed++ ; MRIsetVoxVal(mri, x, y, z, 0, WM_hypointensities) ; } } } } printf("%d voxels changed to hypointensity...\n", changed) ; MHTfree(&mht) ; MRIfree(&mri_dist) ; return(NO_ERROR) ; }
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) ; }