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, *in_fname, *out_fname ; int ac, nargs, i, label ; MRI *mri_in, *mri_out, *mri_kernel, *mri_smoothed ; /* rkt: check for and handle version tag */ nargs = handle_version_option (argc, argv, "$Id: mri_extract_label.c,v 1.13 2011/03/02 00:04:15 nicks Exp $", "$Name: $"); if (nargs && argc - nargs == 1) exit (0); argc -= nargs; Progname = argv[0] ; ErrorInit(NULL, NULL, NULL) ; DiagInit(NULL, NULL, NULL) ; 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() ; in_fname = argv[1] ; out_fname = argv[argc-1] ; printf("reading volume from %s...\n", in_fname) ; mri_in = MRIread(in_fname) ; if (!mri_in) ErrorExit(ERROR_NOFILE, "%s: could not read MRI volume %s", Progname, in_fname) ; if (out_like_fname) { MRI *mri_tmp = MRIread(out_like_fname) ; if (!mri_tmp) ErrorExit (ERROR_NOFILE, "%s: could not read template volume from %s", out_like_fname) ; mri_out = MRIalloc(mri_tmp->width, mri_tmp->height, mri_tmp->depth, mri_tmp->type) ; /* MRIcopyHeader(mri_tmp, mri_out) ;*/ MRIfree(&mri_tmp) ; } else mri_out = MRIclone(mri_in, NULL) ; for (i = 2 ; i < argc-1 ; i++) { label = atoi(argv[i]) ; printf("extracting label %d (%s)\n", label, cma_label_to_name(label)) ; extract_labeled_image(mri_in, transform, label, mri_out) ; } if (!FZERO(sigma)) { printf("smoothing extracted volume...\n") ; mri_kernel = MRIgaussian1d(sigma, 10*sigma) ; mri_smoothed = MRIconvolveGaussian(mri_out, NULL, mri_kernel) ; MRIfree(&mri_out) ; mri_out = mri_smoothed ; } /* removed for gcc3.3 * vsprintf(out_fname, out_fname, (va_list) &label) ; */ if (dilate > 0) { int i ; printf("dilating output volume %d times...\n", dilate) ; for (i = 0 ; i < dilate ; i++) MRIdilate(mri_out, mri_out) ; } if (erode > 0) { int i ; printf("eroding output volume %d times...\n", erode) ; for (i = 0 ; i < erode ; i++) MRIerode(mri_out, mri_out) ; } printf("writing output to %s.\n", out_fname) ; MRIwrite(mri_out, out_fname) ; if (exit_none_found && (nvoxels == 0)) { printf("No voxels with specified label were found!\n"); exit(1); } exit(0) ; return(0) ; /* for ansi */ }
/*---------------------------------------------------------------------- Parameters: Description: ----------------------------------------------------------------------*/ static int get_option(int argc, char *argv[]) { int nargs = 0 ; char *option ; option = argv[1] + 1 ; /* past '-' */ if (!stricmp(option, "-help")) print_help() ; else if (!stricmp(option, "gaussian")) { if (sscanf(argv[2], "%f", &gaussian_sigma) < 1) ErrorExit(ERROR_BADPARM, "%s: could not scan sigma of Gaussian from %s", Progname, argv[2]) ; if (gaussian_sigma <= 0.0f) ErrorExit(ERROR_BADPARM, "%s: Gaussian sigma must be positive",Progname); mri_gaussian = MRIgaussian1d(gaussian_sigma, 0) ; filter_type = FILTER_GAUSSIAN ; nargs = 1 ; } else if (!stricmp(option, "cpolv")) filter_type = FILTER_CPOLV_MEDIAN ; else if (!stricmp(option, "minmax")) filter_type = FILTER_MINMAX ; else if (!stricmp(option, "median")) filter_type = FILTER_MEDIAN ; else if (!stricmp(option, "none")) filter_type = FILTER_NONE ; else if (!stricmp(option, "mean")) filter_type = FILTER_MEAN ; else if (!stricmp(option, "-version")) print_version() ; else if (!stricmp(option, "blur")) { if (sscanf(argv[2], "%f", &blur_sigma) < 1) ErrorExit(ERROR_BADPARM, "%s: could not scan blurring sigma from '%s'", Progname, argv[2]) ; if (blur_sigma < 0.0f) ErrorExit(ERROR_BADPARM, "%s: blurring sigma must be positive",Progname); nargs = 1 ; } else switch (toupper(*option)) { case 'F': if (sscanf(argv[2], "%d", &filter_window_size) < 1) ErrorExit(ERROR_BADPARM, "%s: could not scan window size from '%s'", Progname, argv[2]) ; if (filter_window_size < 3) ErrorExit(ERROR_BADPARM, "%s: offset window size must be > 3",Progname); nargs = 1 ; break ; case 'N': no_offset =1 ; printf("not using offset in filtering\n") ; break ; case 'W': if (sscanf(argv[2], "%d", &offset_window_size) < 1) ErrorExit(ERROR_BADPARM, "%s: could not scan window size from '%s'", Progname, argv[2]) ; if (offset_window_size < 3) ErrorExit(ERROR_BADPARM, "%s: offset window size must be > 3",Progname); nargs = 1 ; break ; case 'B': if (sscanf(argv[2], "%f", &blur_sigma) < 1) ErrorExit(ERROR_BADPARM, "%s: could not scan blurring sigma from '%s'", Progname, argv[2]) ; if (blur_sigma < 0.0f) ErrorExit(ERROR_BADPARM, "%s: blurring sigma must be positive",Progname); nargs = 1 ; break ; case 'R': sscanf(argv[2], "%d", ®ion_size) ; nargs = 1 ; if (DIAG_VERBOSE_ON && (Gdiag & DIAG_SHOW)) fprintf(stderr, "using region size = %d\n", region_size) ; break ; case '?': case 'U': print_usage() ; exit(1) ; break ; default: fprintf(stderr, "unknown option %s\n", argv[1]) ; exit(1) ; break ; } return(nargs) ; }
int main(int argc, char *argv[]) { char **av ; int ac, nargs, width, height, depth, x, y, z, xborder, yborder, zborder, xrborder, yrborder, zrborder ; char *in_fname, *out_fname ; MRI *mri_smooth, *mri_grad, *mri_filter_src, *mri_filter_dst, *mri_dst, *mri_tmp, *mri_blur, *mri_src, *mri_filtered, *mri_direction, *mri_offset, *mri_up, *mri_polv, *mri_dir, *mri_clip, *mri_full ; MRI_REGION region, clip_region ; /* rkt: check for and handle version tag */ nargs = handle_version_option (argc, argv, "$Id: mri_nlfilter.c,v 1.14 2011/03/02 00:04:23 nicks Exp $", "$Name: $"); if (nargs && argc - nargs == 1) exit (0); argc -= nargs; Progname = argv[0] ; ErrorInit(NULL, NULL, NULL) ; DiagInit(NULL, NULL, NULL) ; 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() ; in_fname = argv[1] ; out_fname = argv[2] ; mri_full = mri_src = MRIread(in_fname) ; if (!mri_src) ErrorExit(ERROR_NOFILE, "%s: could not read '%s'", Progname, in_fname) ; if (!FZERO(blur_sigma)) /* allocate a blurring kernel */ { mri_blur = MRIgaussian1d(blur_sigma, 0) ; if (!mri_blur) ErrorExit(ERROR_BADPARM, "%s: could not allocate blurring kernel with sigma=%2.3f", Progname, blur_sigma) ; } else mri_blur = NULL ; MRIboundingBox(mri_full, 0, &clip_region) ; REGIONexpand(&clip_region, &clip_region, (filter_window_size+1)/2) ; mri_src = MRIextractRegion(mri_full, NULL, &clip_region) ; width = mri_src->width ; height = mri_src->height ; depth = mri_src->depth ; mri_dst = MRIclone(mri_src, NULL) ; if (!mri_dst) ErrorExit(ERROR_NOFILE, "%s: could allocate space for destination image", Progname) ; for (z = 0 ; z < depth ; z += region_size) { for (y = 0 ; y < height ; y += region_size) { DiagHeartbeat((float)(z*height+y) / (float)(height*(depth-1))) ; for (x = 0 ; x < width ; x += region_size) { region.x = x ; region.y = y ; region.z = z ; region.dx = region.dy = region.dz = region_size ; if (region.x == 142) DiagBreak() ; REGIONexpand(®ion, ®ion, (filter_window_size+1)/2) ; MRIclipRegion(mri_src, ®ion, ®ion) ; if (region.x == 142) DiagBreak() ; /* check for < 0 width regions */ xborder = x-region.x ; yborder = y-region.y ; zborder = z-region.z ; xrborder = MAX(0, (region.dx-xborder) - region_size) ; yrborder = MAX(0, (region.dy-yborder) - region_size) ; zrborder = MAX(0, (region.dz-zborder) - region_size) ; #if 0 if (region.dx < 2*xborder || region.dy<2*yborder||region.dz<2*zborder) continue ; #endif if (DIAG_VERBOSE_ON && (Gdiag & DIAG_SHOW)) fprintf(stderr, "extracting region (%d, %d, %d) --> (%d, %d, %d)...", region.x,region.y,region.z, region.x+region.dx-1, region.y+region.dy-1,region.z+region.dz-1) ; mri_clip = MRIextractRegion(mri_src, NULL, ®ion) ; if (DIAG_VERBOSE_ON && (Gdiag & DIAG_SHOW)) fprintf(stderr, "done.\nsmoothing region and up-sampling...") ; if (mri_blur) /* smooth the input image to generate offset field */ mri_smooth = MRIconvolveGaussian(mri_clip, NULL, mri_blur) ; else mri_smooth = MRIcopy(mri_clip, NULL) ; /* no smoothing */ if (!mri_smooth) ErrorExit(ERROR_BADPARM, "%s: image smoothing failed", Progname) ; /* now up-sample the smoothed image, and compute offset field in up-sampled domain */ mri_up = MRIupsample2(mri_smooth, NULL) ; if (!mri_up) ErrorExit(ERROR_BADPARM, "%s: up sampling failed", Progname) ; MRIfree(&mri_smooth) ; if (DIAG_VERBOSE_ON && (Gdiag & DIAG_SHOW)) fprintf(stderr, "done.\n") ; mri_smooth = mri_up ; mri_grad = MRIsobel(mri_smooth, NULL, NULL) ; mri_dir = MRIclone(mri_smooth, NULL) ; MRIfree(&mri_smooth) ; if (DIAG_VERBOSE_ON && (Gdiag & DIAG_SHOW)) fprintf(stderr, "computing direction map...") ; mri_direction = MRIoffsetDirection(mri_grad, offset_window_size, NULL, mri_dir) ; if (DIAG_VERBOSE_ON && (Gdiag & DIAG_SHOW)) fprintf(stderr, "computing offset magnitudes...") ; MRIfree(&mri_grad) ; mri_offset = MRIoffsetMagnitude(mri_direction, NULL, offset_search_len); MRIfree(&mri_direction) ; if (!mri_offset) ErrorExit(ERROR_NOMEMORY, "%s: offset calculation failed", Progname) ; if (DIAG_VERBOSE_ON && (Gdiag & DIAG_SHOW)) fprintf(stderr, "done.\nfiltering image...") ; mri_filter_src = MRIupsample2(mri_clip, NULL) ; MRIfree(&mri_clip) ; switch (filter_type) { case FILTER_CPOLV_MEDIAN: mri_polv = MRIplaneOfLeastVarianceNormal(mri_filter_src,NULL,5); mri_filter_dst = MRIpolvMedian(mri_filter_src, NULL, mri_polv,filter_window_size); MRIfree(&mri_polv) ; break ; case FILTER_GAUSSIAN: mri_filter_dst = MRIconvolveGaussian(mri_filter_src, NULL, mri_gaussian) ; if (!mri_filter_dst) ErrorExit(ERROR_NOMEMORY, "%s: could not allocate temporary buffer space",Progname); break ; case FILTER_MEDIAN: mri_filter_dst = MRImedian(mri_filter_src,NULL,filter_window_size, NULL); if (!mri_filter_dst) ErrorExit(ERROR_NOMEMORY, "%s: could not allocate temporary buffer space",Progname); break ; case FILTER_MEAN: mri_filter_dst = MRImean(mri_filter_src, NULL, filter_window_size) ; if (!mri_filter_dst) ErrorExit(ERROR_NOMEMORY, "%s: could not allocate temporary buffer space",Progname); break ; case FILTER_MINMAX: mri_filter_dst = MRIminmax(mri_filter_src, NULL, mri_dir, filter_window_size) ; if (!mri_filter_dst) ErrorExit(ERROR_NOMEMORY, "%s: could not allocate space for filtered image", Progname) ; break ; default: mri_filter_dst = MRIcopy(mri_filter_src, NULL) ; /* no filtering */ break ; } MRIfree(&mri_dir) ; MRIfree(&mri_filter_src) ; if (no_offset) { mri_filtered = MRIcopy(mri_filter_dst, NULL) ; } else { if (DIAG_VERBOSE_ON && (Gdiag & DIAG_SHOW)) fprintf(stderr, "applying offset field...") ; if (Gdiag & DIAG_WRITE) MRIwrite(mri_filter_dst, "minmax.mgz") ; mri_filtered = MRIapplyOffset(mri_filter_dst, NULL, mri_offset) ; if (!mri_filtered) ErrorExit(ERROR_NOMEMORY, "%s: could not allocate filtered image", Progname) ; if (DIAG_VERBOSE_ON && (Gdiag & DIAG_SHOW)) fprintf(stderr, "done.\n") ; if (region.x == 142) DiagBreak() ; MRIfree(&mri_offset) ; } MRIfree(&mri_filter_dst) ; if (Gdiag & DIAG_WRITE) MRIwrite(mri_filtered, "upfilt.mgz") ; mri_tmp = MRIdownsample2(mri_filtered, NULL) ; MRIfree(&mri_filtered) ; if (Gdiag & DIAG_WRITE) MRIwrite(mri_tmp, "downfilt.mgz") ; region.x += xborder ; region.y += yborder ; region.z += zborder ; #if 0 region.dx -=2*xborder; region.dy-= 2*yborder; region.dz -= 2 * zborder; #else region.dx -= xrborder + xborder; region.dy -= yrborder + yborder; region.dz -= zrborder + zborder; #endif if (region.dx <= 0 || region.dy <= 0 || region.dz <= 0) { fprintf(stderr, "invalid region: (%d,%d,%d) --> (%d,%d,%d)\n", region.x,region.y,region.z,region.dx,region.dy,region.dz); } else MRIextractIntoRegion(mri_tmp,mri_dst,xborder,yborder,zborder,®ion); MRIfree(&mri_tmp); } } } MRIextractIntoRegion(mri_dst,mri_full, 0, 0, 0, &clip_region); MRIfree(&mri_dst) ; if (DIAG_VERBOSE_ON && (Gdiag & DIAG_SHOW)) fprintf(stderr, "writing output image %s...", out_fname) ; MRIwrite(mri_full, out_fname) ; MRIfree(&mri_full) ; if (DIAG_VERBOSE_ON && (Gdiag & DIAG_SHOW)) fprintf(stderr, "done.\n") ; exit(0) ; return(0) ; /* for ansi */ }
MRI * MRIremoveWrongDirection(MRI *mri_src, MRI *mri_dst, int wsize, float low_thresh, float hi_thresh, MRI *mri_labels) { MRI *mri_kernel, *mri_smooth ; int x, y, z, width, height, depth, val, nchanged, ntested ; float dir /*, d2I_dg2*/ ; mri_kernel = MRIgaussian1d(blur_sigma, 100) ; fprintf(stderr, "smoothing T1 volume with sigma = %2.3f\n", blur_sigma) ; mri_smooth = MRIclone(mri_src, NULL) ; MRIconvolveGaussian(mri_src, mri_smooth, mri_kernel) ; MRIfree(&mri_kernel) ; if (!mri_dst) { mri_dst = MRIclone(mri_src, NULL) ; } nchanged = ntested = 0 ; width = mri_src->width ; height = mri_src->height ; depth = mri_src->depth ; for (z = 0 ; z < depth ; z++) { for (y = 0 ; y < height ; y++) { for (x = 0 ; x < width ; x++) { if (z == 101 && y == 133 && x == 152) { DiagBreak() ; } if (z == 87 && y == 88 && x == 163) { DiagBreak() ; } if (z == 88 && y == 89 && x == 163) { DiagBreak() ; } val = MRIgetVoxVal(mri_src, x, y, z, 0) ; if (val >= low_thresh && val <= hi_thresh) { ntested++ ; dir = MRIvoxelDirection(mri_smooth, x, y, z, wsize) ; if (dir > 0.0) { #if 0 d2I_dg2 = MRIvoxelGradientDir2ndDerivative(mri_smooth,x,y,z,wsize); if (d2I_dg2 < 0) #endif { nchanged++ ; val = 0 ; if (mri_labels) { MRIsetVoxVal(mri_labels, x, y, z, 0, 255) ; } } } } MRIsetVoxVal(mri_dst, x, y, z, 0, val) ; } } } if (Gdiag & DIAG_SHOW) { fprintf(stderr, " %8d voxels tested (%2.2f%%)\n", ntested, 100.0f*(float)ntested/ (float)(width*height*depth)); fprintf(stderr, " %8d voxels changed (%2.2f%%)\n", nchanged, 100.0f*(float)nchanged/ (float)(width*height*depth)); } MRIfree(&mri_smooth) ; return(mri_dst) ; }
/*---------------------------------------------------------------------- Parameters: Description: ----------------------------------------------------------------------*/ static int get_option(int argc, char *argv[]) { int nargs = 0 ; char *option ; float f ; option = argv[1] + 1 ; /* past '-' */ if (!stricmp(option, "-help")) { print_help() ; } else if (!stricmp(option, "-version")) { print_version() ; } else if (!stricmp(option, "synth")) { synth_name = argv[2] ; nargs = 1 ; } else if (!stricmp(option, "overlay")) { mri_overlay = MRIread(argv[2]) ; nargs = 1 ; if (mri_overlay == NULL) ErrorExit(ERROR_NOFILE, "%s: could not read overlay from %s", argv[2]) ; parms.niterations = 0 ; // this will disable the actual flattening } else if (!stricmp(option, "label_overlay") || !stricmp(option, "overlay_label")) { label_overlay = LabelRead(NULL, argv[2]) ; nargs = 1 ; if (label_overlay == NULL) ErrorExit(ERROR_NOFILE, "%s: could not read label overlay from %s", Progname,argv[2]) ; } else if (!stricmp(option, "norand")) { setRandomSeed(0L) ; } else if (!stricmp(option, "sphere")) { sphere_flag = 1 ; } else if (!stricmp(option, "plane")) { plane_flag = 1 ; } else if (!stricmp(option, "rescale")) { rescale = atof(argv[2]) ; nargs = 1 ; fprintf(stderr, "rescaling brain by %2.3f\n", rescale) ; } else if (!stricmp(option, "dilate")) { dilate = atoi(argv[2]) ; nargs = 1 ; fprintf(stderr, "dilating cuts %d times\n", dilate) ; } else if (!stricmp(option, "dist")) { sscanf(argv[2], "%f", &parms.l_dist) ; nargs = 1 ; fprintf(stderr, "l_dist = %2.3f\n", parms.l_dist) ; } else if (!stricmp(option, "expand")) { sscanf(argv[2], "%f", &parms.l_expand) ; nargs = 1 ; printf("setting l_expand = %2.3f\n", parms.l_expand) ; } else if (!stricmp(option, "unfold")) { MRI *mri_kernel, *mri_tmp ; sscanf(argv[2], "%f", &parms.l_unfold) ; mri_tmp = MRIread(argv[3]) ; if (!mri_tmp) ErrorExit(ERROR_NOFILE, "%s: could not read distance map %s...\n", Progname, argv[3]) ; mri_kernel = MRIgaussian1d(1.0, -1) ; parms.mri_dist = MRIconvolveGaussian(mri_tmp, NULL, mri_kernel) ; MRIfree(&mri_kernel) ; MRIfree(&mri_tmp) ; nargs = 2 ; fprintf(stderr, "l_unfold = %2.3f\n", parms.l_unfold) ; } else if (!stricmp(option, "boundary")) { sscanf(argv[2], "%f", &parms.l_boundary) ; nargs = 1 ; fprintf(stderr, "l_boundary = %2.3f\n", parms.l_boundary) ; } else if (!stricmp(option, "lm")) { parms.integration_type = INTEGRATE_LINE_MINIMIZE ; fprintf(stderr, "integrating with line minimization\n") ; } else if (!stricmp(option, "dt")) { parms.dt = atof(argv[2]) ; parms.base_dt = base_dt_scale*parms.dt ; nargs = 1 ; fprintf(stderr, "momentum with dt = %2.2f\n", parms.dt) ; } else if (!stricmp(option, "curv")) { sscanf(argv[2], "%f", &parms.l_curv) ; nargs = 1 ; fprintf(stderr, "using l_curv = %2.3f\n", parms.l_curv) ; } else if (!stricmp(option, "nospring")) { nospring = 1 ; } else if (!stricmp(option, "area")) { sscanf(argv[2], "%f", &parms.l_area) ; nargs = 1 ; fprintf(stderr, "using l_area = %2.3f\n", parms.l_area) ; } else if (!stricmp(option, "nlarea")) { sscanf(argv[2], "%f", &parms.l_nlarea) ; nargs = 1 ; fprintf(stderr, "using l_nlarea = %2.3f\n", parms.l_nlarea) ; } else if (!stricmp(option, "boundary")) { sscanf(argv[2], "%f", &parms.l_boundary) ; nargs = 1 ; fprintf(stderr, "using l_boundary = %2.3f\n", parms.l_boundary) ; } else if (!stricmp(option, "adaptive")) { parms.integration_type = INTEGRATE_ADAPTIVE ; fprintf(stderr, "using adaptive time step integration\n") ; } else if (!stricmp(option, "nbrs")) { nbrs = atoi(argv[2]) ; nargs = 1 ; fprintf(stderr, "using neighborhood size=%d\n", nbrs) ; } else if (!stricmp(option, "spring")) { sscanf(argv[2], "%f", &parms.l_spring) ; nargs = 1 ; fprintf(stderr, "using l_spring = %2.3f\n", parms.l_spring) ; } else if (!stricmp(option, "name")) { strcpy(parms.base_name, argv[2]) ; nargs = 1 ; fprintf(stderr, "using base name = %s\n", parms.base_name) ; } else if (!stricmp(option, "angle")) { sscanf(argv[2], "%f", &parms.l_angle) ; nargs = 1 ; fprintf(stderr, "using l_angle = %2.3f\n", parms.l_angle) ; } else if (!stricmp(option, "area")) { sscanf(argv[2], "%f", &parms.l_area) ; nargs = 1 ; fprintf(stderr, "using l_area = %2.3f\n", parms.l_area) ; } else if (!stricmp(option, "tol")) { if (sscanf(argv[2], "%e", &f) < 1) ErrorExit(ERROR_BADPARM, "%s: could not scan tol from %s", Progname, argv[2]) ; parms.tol = (double)f ; nargs = 1 ; fprintf(stderr, "using tol = %2.2e\n", (float)parms.tol) ; } else if (!stricmp(option, "error_ratio")) { parms.error_ratio = atof(argv[2]) ; nargs = 1 ; fprintf(stderr, "error_ratio=%2.3f\n", parms.error_ratio) ; } else if (!stricmp(option, "dt_inc")) { parms.dt_increase = atof(argv[2]) ; nargs = 1 ; fprintf(stderr, "dt_increase=%2.3f\n", parms.dt_increase) ; } else if (!stricmp(option, "complete")) { parms.complete_dist_mat = 1 ; fprintf(stderr, "using complete distance matrix\n") ; } else if (!stricmp(option, "vnum") || (!stricmp(option, "distances"))) { parms.nbhd_size = atof(argv[2]) ; parms.max_nbrs = atof(argv[3]) ; nargs = 2 ; fprintf(stderr, "sampling %d neighbors out to a distance of %d mm\n", parms.max_nbrs, parms.nbhd_size) ; } else if (!stricmp(option, "dt_dec")) { parms.dt_decrease = atof(argv[2]) ; nargs = 1 ; fprintf(stderr, "dt_decrease=%2.3f\n", parms.dt_decrease) ; } else if (!stricmp(option, "ou")) { original_unfold_surf_name = argv[2] ; nargs = 1 ; fprintf(stderr,"reading original unfolding surface from %s...\n", original_unfold_surf_name); } else if (!stricmp(option, "as")) { parms.area_coef_scale = atof(argv[2]) ; printf("setting area coef scale to %2.3f\n", parms.area_coef_scale) ; nargs = 1 ; } else switch (toupper(*option)) { case 'P': max_passes = atoi(argv[2]) ; fprintf(stderr, "limitting unfolding to %d passes\n", max_passes) ; nargs = 1 ; break ; case '1': one_surf_flag = 1 ; /* patch is only surface file */ break ; case 'O': original_surf_name = argv[2] ; nargs = 1 ; fprintf(stderr,"reading original surface from %s...\n", original_surf_name); break ; case 'B': base_dt_scale = atof(argv[2]) ; parms.base_dt = base_dt_scale*parms.dt ; nargs = 1; break ; case 'V': Gdiag_no = atoi(argv[2]) ; nargs = 1 ; break ; case 'L': label_fname = argv[2] ; dilate_label = atof(argv[3]) ; nargs = 2; printf("loading label %s and dilating it %d times before flattening\n", label_fname, dilate_label) ; break ; case 'D': disturb = atof(argv[2]) ; nargs = 1 ; fprintf(stderr, "disturbing vertex positions by %2.3f\n", (float)disturb) ; break ; case 'R': randomly_flatten = !randomly_flatten ; fprintf(stderr, "using random placement for flattening.\n") ; break ; case 'M': parms.integration_type = INTEGRATE_MOMENTUM ; parms.momentum = atof(argv[2]) ; nargs = 1 ; fprintf(stderr, "momentum = %2.2f\n", (float)parms.momentum) ; break ; case 'S': scale = atof(argv[2]) ; fprintf(stderr, "scaling brain by = %2.3f\n", (float)scale) ; nargs = 1 ; break ; case 'W': Gdiag |= DIAG_WRITE ; sscanf(argv[2], "%d", &parms.write_iterations) ; nargs = 1 ; fprintf(stderr, "using write iterations = %d\n", parms.write_iterations) ; break ; case 'I': inflate = 1 ; fprintf(stderr, "inflating brain...\n") ; break ; case 'A': sscanf(argv[2], "%d", &parms.n_averages) ; nargs = 1 ; fprintf(stderr, "using n_averages = %d\n", parms.n_averages) ; break ; case 'N': sscanf(argv[2], "%d", &parms.niterations) ; nargs = 1 ; fprintf(stderr, "using niterations = %d\n", parms.niterations) ; break ; default: case 'H': case '?': case 'U': print_help() ; break ; } return(nargs) ; }
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 */ }
int main(int argc, char *argv[]) { char **av, *cp ; int ac, nargs, i, dof, no_transform, which, sno = 0, nsubjects = 0 ; MRI *mri=0, *mri_mean = NULL, *mri_std=0, *mri_T1=0,*mri_binary=0,*mri_dof=NULL, *mri_priors = NULL ; char *subject_name, *out_fname, fname[STRLEN] ; /* LTA *lta;*/ MRI *mri_tmp=0 ; /* rkt: check for and handle version tag */ nargs = handle_version_option (argc, argv, "$Id: mri_make_template.c,v 1.26 2011/03/02 00:04:22 nicks Exp $", "$Name: stable5 $"); if (nargs && argc - nargs == 1) exit (0); argc -= nargs; Progname = argv[0] ; ErrorInit(NULL, NULL, NULL) ; DiagInit(NULL, NULL, NULL) ; ac = argc ; av = argv ; for ( ; argc > 1 && ISOPTION(*argv[1]) ; argc--, argv++) { nargs = get_option(argc, argv) ; argc -= nargs ; argv += nargs ; } if (!strlen(subjects_dir)) { cp = getenv("SUBJECTS_DIR") ; if (!cp) ErrorExit(ERROR_BADPARM,"%s: SUBJECTS_DIR not defined in environment.\n", Progname) ; strcpy(subjects_dir, cp) ; } if (argc < 3) usage_exit(1) ; out_fname = argv[argc-1] ; no_transform = first_transform ; if (binary_name) /* generate binarized volume with priors and */ { /* separate means and variances */ for (which = BUILD_PRIORS ; which <= OFF_STATS ; which++) { /* for each subject specified on cmd line */ for (dof = 0, i = 1 ; i < argc-1 ; i++) { if (*argv[i] == '-') /* don't do transform for next subject */ { no_transform = 1 ; continue ; } dof++ ; subject_name = argv[i] ; if (which != BUILD_PRIORS) { sprintf(fname, "%s/%s/mri/%s", subjects_dir, subject_name, T1_name); fprintf(stderr, "%d of %d: reading %s...\n", i, argc-2, fname) ; mri_T1 = MRIread(fname) ; if (!mri_T1) ErrorExit(ERROR_NOFILE,"%s: could not open volume %s", Progname,fname); } sprintf(fname, "%s/%s/mri/%s",subjects_dir,subject_name,binary_name); fprintf(stderr, "%d of %d: reading %s...\n", i, argc-2, fname) ; mri_binary = MRIread(fname) ; if (!mri_binary) ErrorExit(ERROR_NOFILE,"%s: could not open volume %s", Progname,fname); /* only count voxels which are mostly labeled */ MRIbinarize(mri_binary, mri_binary, WM_MIN_VAL, 0, 100) ; if (transform_fname && no_transform-- <= 0) { sprintf(fname, "%s/%s/mri/transforms/%s", subjects_dir, subject_name, transform_fname) ; fprintf(stderr, "reading transform %s...\n", fname) ; //////////////////////////////////////////////////////// #if 1 { TRANSFORM *transform ; transform = TransformRead(fname) ; if (transform == NULL) ErrorExit(ERROR_NOFILE, "%s: could not open transform file %s\n",Progname, fname) ; mri_tmp = TransformApply(transform, mri_T1, NULL) ; TransformFree(&transform) ; } #else lta = LTAreadEx(fname); if (lta == NULL) ErrorExit(ERROR_NOFILE, "%s: could not open transform file %s\n", Progname, fname) ; /* LTAtransform() runs either MRIapplyRASlinearTransform() for RAS2RAS or MRIlinearTransform() for Vox2Vox. */ /* MRIlinearTransform() calls MRIlinearTransformInterp() */ mri_tmp = LTAtransform(mri_T1, NULL, lta); MRIfree(&mri_T1) ; mri_T1 = mri_tmp ; LTAfree(<a); lta = NULL; #endif if (DIAG_VERBOSE_ON) fprintf(stderr, "transform application complete.\n") ; } if (which == BUILD_PRIORS) { mri_priors = MRIupdatePriors(mri_binary, mri_priors) ; } else { if (!mri_mean) { mri_dof = MRIalloc(mri_T1->width, mri_T1->height, mri_T1->depth, MRI_UCHAR) ; mri_mean = MRIalloc(mri_T1->width, mri_T1->height,mri_T1->depth,MRI_FLOAT); mri_std = MRIalloc(mri_T1->width,mri_T1->height,mri_T1->depth,MRI_FLOAT); if (!mri_mean || !mri_std) ErrorExit(ERROR_NOMEMORY, "%s: could not allocate templates.\n", Progname) ; } if (DIAG_VERBOSE_ON) fprintf(stderr, "updating mean and variance estimates...\n") ; if (which == ON_STATS) { MRIaccumulateMaskedMeansAndVariances(mri_T1, mri_binary, mri_dof, 90, 100, mri_mean, mri_std) ; fprintf(stderr, "T1 = %d, binary = %d, mean = %2.1f\n", (int)MRIgetVoxVal(mri_T1, 141,100,127,0), MRIvox(mri_binary, 141,100,127), MRIFvox(mri_mean, 141,100,127)) ; } else /* computing means and vars for off */ MRIaccumulateMaskedMeansAndVariances(mri_T1, mri_binary, mri_dof, 0, WM_MIN_VAL-1, mri_mean, mri_std) ; MRIfree(&mri_T1) ; } MRIfree(&mri_binary) ; } if (which == BUILD_PRIORS) { mri = MRIcomputePriors(mri_priors, dof, NULL) ; MRIfree(&mri_priors) ; fprintf(stderr, "writing priors to %s...\n", out_fname) ; } else { MRIcomputeMaskedMeansAndStds(mri_mean, mri_std, mri_dof) ; mri_mean->dof = dof ; fprintf(stderr, "writing T1 means with %d dof to %s...\n", mri_mean->dof, out_fname) ; if (!which) MRIwrite(mri_mean, out_fname) ; else MRIappend(mri_mean, out_fname) ; MRIfree(&mri_mean) ; fprintf(stderr, "writing T1 variances to %s...\n", out_fname); if (dof <= 1) MRIreplaceValues(mri_std, mri_std, 0, 1) ; mri = mri_std ; } if (!which) MRIwrite(mri, out_fname) ; else MRIappend(mri, out_fname) ; MRIfree(&mri) ; } } else { /* for each subject specified on cmd line */ if (xform_mean_fname) { m_xform_mean = MatrixAlloc(4,4,MATRIX_REAL) ; /* m_xform_covariance = MatrixAlloc(12,12,MATRIX_REAL) ;*/ } dof = 0; for (i = 1 ; i < argc-1 ; i++) { if (*argv[i] == '-') { /* don't do transform for next subject */ no_transform = 1 ; continue ; } dof++ ; subject_name = argv[i] ; sprintf(fname, "%s/%s/mri/%s", subjects_dir, subject_name, T1_name); fprintf(stderr, "%d of %d: reading %s...\n", i, argc-2, fname) ; mri_T1 = MRIread(fname) ; if (!mri_T1) ErrorExit(ERROR_NOFILE,"%s: could not open volume %s",Progname,fname); check_mri(mri_T1) ; if (binarize) MRIbinarize(mri_T1, mri_T1, binarize, 0, 1) ; if (erode) { int i ; printf("eroding input %d times\n", erode) ; for (i = 0 ; i < erode ; i++) MRIerode(mri_T1, mri_T1) ; } if (open) { int i ; printf("opening input %d times\n", open) ; for (i = 0 ; i < open ; i++) MRIerode(mri_T1, mri_T1) ; for (i = 0 ; i < open ; i++) MRIdilate(mri_T1, mri_T1) ; } check_mri(mri_T1) ; if (transform_fname) { sprintf(fname, "%s/%s/mri/transforms/%s", subjects_dir, subject_name, transform_fname) ; fprintf(stderr, "reading transform %s...\n", fname) ; //////////////////////////////////////////////////////// #if 1 { TRANSFORM *transform ; transform = TransformRead(fname) ; if (transform == NULL) ErrorExit(ERROR_NOFILE, "%s: could not open transform file %s\n",Progname, fname) ; mri_tmp = TransformApply(transform, mri_T1, NULL) ; if (DIAG_VERBOSE_ON) MRIwrite(mri_tmp, "t1.mgz") ; TransformFree(&transform) ; } #else lta = LTAreadEx(fname); if (lta == NULL) ErrorExit(ERROR_NOFILE, "%s: could not open transform file %s\n", Progname, fname) ; printf("transform matrix -----------------------\n"); MatrixPrint(stdout,lta->xforms[0].m_L); /* LTAtransform() runs either MRIapplyRASlinearTransform() for RAS2RAS or MRIlinearTransform() for Vox2Vox. */ /* MRIlinearTransform() calls MRIlinearTransformInterp() */ mri_tmp = LTAtransform(mri_T1, NULL, lta); printf("----- -----------------------\n"); LTAfree(<a); #endif MRIfree(&mri_T1); mri_T1 = mri_tmp ; // reassign pointers if (DIAG_VERBOSE_ON) fprintf(stderr, "transform application complete.\n") ; } if (!mri_mean) { mri_mean = MRIalloc(mri_T1->width, mri_T1->height, mri_T1->depth, MRI_FLOAT) ; mri_std = MRIalloc(mri_T1->width, mri_T1->height, mri_T1->depth, MRI_FLOAT) ; if (!mri_mean || !mri_std) ErrorExit(ERROR_NOMEMORY, "%s: could not allocate templates.\n", Progname) ; // if(transform_fname == NULL){ if (DIAG_VERBOSE_ON) printf("Copying geometry\n"); MRIcopyHeader(mri_T1,mri_mean); MRIcopyHeader(mri_T1,mri_std); // } } check_mri(mri_mean) ; if (!stats_only) { if (DIAG_VERBOSE_ON) fprintf(stderr, "updating mean and variance estimates...\n") ; MRIaccumulateMeansAndVariances(mri_T1, mri_mean, mri_std) ; } check_mri(mri_mean) ; if (DIAG_VERBOSE_ON) MRIwrite(mri_mean, "t2.mgz") ; MRIfree(&mri_T1) ; no_transform = 0; } /* end loop over subjects */ if (xform_mean_fname) { FILE *fp ; VECTOR *v = NULL, *vT = NULL ; MATRIX *m_vvT = NULL ; int rows, cols ; nsubjects = sno ; fp = fopen(xform_covariance_fname, "w") ; if (!fp) ErrorExit(ERROR_NOFILE, "%s: could not open covariance file %s", Progname, xform_covariance_fname) ; fprintf(fp, "nsubjects=%d\n", nsubjects) ; MatrixScalarMul(m_xform_mean, 1.0/(double)nsubjects, m_xform_mean) ; printf("means:\n") ; MatrixPrint(stdout, m_xform_mean) ; MatrixAsciiWrite(xform_mean_fname, m_xform_mean) ; /* subtract the mean from each transform */ rows = m_xform_mean->rows ; cols = m_xform_mean->cols ; for (sno = 0 ; sno < nsubjects ; sno++) { MatrixSubtract(m_xforms[sno], m_xform_mean, m_xforms[sno]) ; v = MatrixReshape(m_xforms[sno], v, rows*cols, 1) ; vT = MatrixTranspose(v, vT) ; m_vvT = MatrixMultiply(v, vT, m_vvT) ; if (!m_xform_covariance) m_xform_covariance = MatrixAlloc(m_vvT->rows, m_vvT->cols,MATRIX_REAL) ; MatrixAdd(m_vvT, m_xform_covariance, m_xform_covariance) ; MatrixAsciiWriteInto(fp, m_xforms[sno]) ; } MatrixScalarMul(m_xform_covariance, 1.0/(double)nsubjects, m_xform_covariance) ; printf("covariance:\n") ; MatrixPrint(stdout, m_xform_covariance) ; MatrixAsciiWriteInto(fp, m_xform_covariance) ; fclose(fp) ; if (stats_only) exit(0) ; } MRIcomputeMeansAndStds(mri_mean, mri_std, dof) ; check_mri(mri_mean) ; check_mri(mri_std) ; mri_mean->dof = dof ; if (smooth) { MRI *mri_kernel, *mri_smooth ; printf("applying smoothing kernel\n") ; mri_kernel = MRIgaussian1d(smooth, 100) ; mri_smooth = MRIconvolveGaussian(mri_mean, NULL, mri_kernel) ; MRIfree(&mri_kernel) ; MRIfree(&mri_mean) ; mri_mean = mri_smooth ; } fprintf(stderr, "\nwriting T1 means with %d dof to %s...\n", mri_mean->dof, out_fname) ; MRIwrite(mri_mean, out_fname) ; MRIfree(&mri_mean) ; if (dof <= 1) /* can't calculate variances - set them to reasonable val */ { // src dst MRIreplaceValues(mri_std, mri_std, 0, 1) ; } if (!novar) { // mri_std contains the variance here (does it?? I don't think so -- BRF) if (!var_fname) { fprintf(stderr, "\nwriting T1 standard deviations to %s...\n", out_fname); MRIappend(mri_std, out_fname) ; } else { fprintf(stderr, "\nwriting T1 standard deviations to %s...\n", var_fname); MRIwrite(mri_std, var_fname) ; } } MRIfree(&mri_std) ; if (mri) MRIfree(&mri); } /* end if binarize */ return(0) ; }
int main(int argc, char *argv[]) { char **av, *out_fname ; int ac, nargs ; GCA_MORPH *gcam ; int msec, minutes, seconds ; struct timeb start ; MRI *mri, *mri_jacobian, *mri_area, *mri_orig_area ; /* rkt: check for and handle version tag */ nargs = handle_version_option (argc, argv, "$Id: mri_jacobian.c,v 1.11 2011/12/10 22:47:57 fischl Exp $", "$Name: $"); 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) ; out_fname = argv[argc-1] ; gcam = GCAMread(argv[1]) ; if (gcam == NULL) ErrorExit(ERROR_BADPARM, "%s: could not read input morph %s\n", Progname,argv[1]); if (Gx >= 0 && atlas == 0) find_debug_node(gcam, Gx, Gy, Gz) ; mri = MRIread(argv[2]) ; if (gcam == NULL) ErrorExit(ERROR_BADPARM, "%s: could not read template volume %s\n", Progname,argv[2]); GCAMrasToVox(gcam, mri) ; if (init || tm3dfile) init_gcam_areas(gcam) ; if (atlas) { mri_area = GCAMwriteMRI(gcam, NULL, GCAM_AREA); mri_orig_area = GCAMwriteMRI(gcam, NULL, GCAM_ORIG_AREA); } else { mri_area = GCAMmorphFieldFromAtlas(gcam, mri, GCAM_AREA, 0, 0); mri_orig_area = GCAMmorphFieldFromAtlas(gcam, mri, GCAM_ORIG_AREA, 0, 0); } if (Gdiag & DIAG_WRITE && DIAG_VERBOSE_ON) { MRIwrite(mri_orig_area, "o.mgz") ; MRIwrite(mri_area, "a.mgz") ; } if (Gx > 0) printf("area = %2.3f, orig = %2.3f\n", MRIgetVoxVal(mri_area, Gx, Gy, Gz,0),MRIgetVoxVal(mri_orig_area,Gx,Gy,Gz,0)) ; if (lta) { double det ; if (lta->type == LINEAR_RAS_TO_RAS) LTArasToVoxelXform(lta, mri, mri) ; det = MatrixDeterminant(lta->xforms[0].m_L) ; printf("correcting transform with det=%2.3f\n", det) ; MRIscalarMul(mri_orig_area, mri_orig_area, 1/det) ; } if (! FZERO(sigma)) { MRI *mri_kernel, *mri_smooth ; mri_kernel = MRIgaussian1d(sigma, 100) ; mri_smooth = MRIconvolveGaussian(mri_area, NULL, mri_kernel) ; MRIfree(&mri_area) ; mri_area = mri_smooth ; mri_smooth = MRIconvolveGaussian(mri_orig_area, NULL, mri_kernel) ; MRIfree(&mri_orig_area) ; mri_orig_area = mri_smooth ; MRIfree(&mri_kernel) ; } if (Gx > 0) printf("after smoothing area = %2.3f, orig = %2.3f\n", MRIgetVoxVal(mri_area, Gx, Gy, Gz,0),MRIgetVoxVal(mri_orig_area,Gx,Gy,Gz,0)) ; mri_jacobian = MRIdivide(mri_area, mri_orig_area, NULL) ; if (Gx > 0) printf("jacobian = %2.3f\n", MRIgetVoxVal(mri_jacobian, Gx, Gy, Gz,0)) ; if (atlas) mask_invalid(gcam, mri_jacobian) ; if (use_log) { MRIlog10(mri_jacobian, NULL, mri_jacobian, 0) ; if (zero_mean) MRIzeroMean(mri_jacobian, mri_jacobian) ; if (Gx > 0) printf("log jacobian = %2.3f\n", MRIgetVoxVal(mri_jacobian, Gx, Gy, Gz,0)) ; } fprintf(stderr, "writing to %s...\n", out_fname) ; MRIwrite(mri_jacobian, out_fname) ; MRIfree(&mri_jacobian) ; if (write_areas) { char fname[STRLEN] ; sprintf(fname, "%s_area.mgz", out_fname) ; printf("writing area to %s\n", fname) ; MRIwrite(mri_area, fname) ; sprintf(fname, "%s_orig_area.mgz", out_fname) ; printf("writing orig area to %s\n", fname) ; MRIwrite(mri_orig_area, fname) ; } if (atlas && DIAG_WRITE && DIAG_VERBOSE_ON) { char fname[STRLEN] ; FileNameRemoveExtension(out_fname, out_fname) ; mri_area = GCAMwriteMRI(gcam, mri_area, GCAM_MEANS); sprintf(fname, "%s_means.mgz", out_fname) ; printf("writing means to %s\n", fname) ; MRIwrite(mri_area, fname) ; sprintf(fname, "%s_labels.mgz", out_fname) ; mri_area = GCAMwriteMRI(gcam, mri_area, GCAM_LABEL); printf("writing labels to %s\n", fname) ; MRIwrite(mri_area, fname) ; } msec = TimerStop(&start) ; seconds = nint((float)msec/1000.0f) ; minutes = seconds / 60 ;seconds = seconds % 60 ; fprintf(stderr, "jacobian calculation took %d minutes and %d seconds.\n", minutes, seconds) ; exit(0) ; return(0) ; }
int main(int argc, char *argv[]) { char *ref_fname, *in_fname, *out_fname, fname[STRLEN], **av ; MRI *mri_ref, *mri_in, *mri_orig, *mri_in_red, *mri_ref_red, *mri_in_tmp, *mri_ref_tmp, *mri_ref_orig, *mri_in_orig ; int ac, nargs, i, msec, minutes, seconds ; struct timeb start ; MATRIX *m_L ; /* rkt: check for and handle version tag */ nargs = handle_version_option (argc, argv, "$Id: mri_linear_register.c,v 1.13 2011/03/02 00:04:22 nicks Exp $", "$Name: stable5 $"); if (nargs && argc - nargs == 1) exit (0); argc -= nargs; parms.mri_crop = NULL ; parms.l_intensity = 1.0f ; parms.niterations = 100 ; parms.levels = -1 ; /* use default */ parms.dt = 1e-6 ; /* was 5e-6 */ parms.tol = INTEGRATION_TOL*5 ; parms.dt = 5e-6 ; /* was 5e-6 */ parms.tol = 1e-3 ; parms.momentum = 0.8 ; parms.max_levels = MAX_LEVELS ; parms.factor = 1.0 ; parms.niterations = 25 ; Progname = argv[0] ; DiagInit(NULL, NULL, NULL) ; ErrorInit(NULL, NULL, NULL) ; ac = argc ; av = argv ; for ( ; argc > 1 && ISOPTION(*argv[1]) ; argc--, argv++) { nargs = get_option(argc, argv) ; argc -= nargs ; argv += nargs ; } if (argc < 4) ErrorExit(ERROR_BADPARM, "usage: %s <in brain> <template> <output file name>\n", Progname) ; in_fname = argv[1] ; ref_fname = argv[2] ; if (xform_mean_fname) { int sno, nsubjects ; FILE *fp ; parms.m_xform_mean = MatrixAsciiRead(xform_mean_fname, NULL) ; if (!parms.m_xform_mean) ErrorExit(Gerror, "%s: could not read parameter means from %s", Progname, xform_mean_fname) ; fp = fopen(xform_covariance_fname, "r") ; if (!fp) ErrorExit(ERROR_NOFILE, "%s: could not read covariances from %s", Progname, xform_covariance_fname) ; fscanf(fp, "nsubjects=%d", &nsubjects) ; printf("reading %d transforms...\n", nsubjects) ; parms.m_xforms = (MATRIX **)calloc(nsubjects, sizeof(MATRIX *)) ; if (!parms.m_xforms) ErrorExit(ERROR_NOMEMORY, "%s: could not allocate array of %d xforms", Progname, nsubjects) ; for (sno = 0 ; sno < nsubjects ; sno++) { parms.m_xforms[sno] = MatrixAsciiReadFrom(fp, NULL) ; if (!parms.m_xforms[sno]) ErrorExit(ERROR_NOMEMORY, "%s: could not allocate %dth xform", Progname, sno) ; } parms.m_xform_covariance = MatrixAsciiReadFrom(fp, NULL) ; if (!parms.m_xform_covariance) ErrorExit(Gerror, "%s: could not read parameter covariance from %s", Progname, xform_covariance_fname) ; fclose(fp) ; parms.l_priors = l_priors ; parms.nxforms = nsubjects ; } out_fname = argv[3] ; FileNameOnly(out_fname, fname) ; FileNameRemoveExtension(fname, fname) ; strcpy(parms.base_name, fname) ; fprintf(stderr, "logging results to %s.log\n", parms.base_name) ; TimerStart(&start) ; fprintf(stderr, "reading '%s'...\n", ref_fname) ; fflush(stderr) ; mri_ref = MRIread(ref_fname) ; if (!mri_ref) ErrorExit(ERROR_NOFILE, "%s: could not open reference volume %s.\n", Progname, ref_fname) ; if (mri_ref->type != MRI_UCHAR) { MRI *mri_tmp ; mri_tmp = MRIchangeType(mri_ref, MRI_UCHAR, 0.0, 0.999, FALSE) ; MRIfree(&mri_ref) ; mri_ref = mri_tmp ; } if (var_fname) /* read in a volume of standard deviations */ { MRI *mri_var, *mri_tmp ; fprintf(stderr, "reading '%s'...\n", var_fname) ; mri_var = MRIread(var_fname) ; if (!mri_var) ErrorExit(ERROR_NOFILE, "%s: could not open variance volume %s.\n", Progname, var_fname) ; mri_tmp = MRIconcatenateFrames(mri_ref, mri_var, NULL) ; MRIfree(&mri_var) ; MRIfree(&mri_ref) ; mri_ref = mri_tmp ; } fprintf(stderr, "reading '%s'...\n", in_fname) ; fflush(stderr) ; mri_orig = mri_in = MRIread(in_fname) ; if (!mri_in) ErrorExit(ERROR_NOFILE, "%s: could not open input volume %s.\n", Progname, in_fname) ; if (mri_in->type != MRI_UCHAR) { MRI *mri_tmp ; mri_orig = mri_tmp = MRIchangeType(mri_in, MRI_UCHAR, 0.0, 0.999, FALSE) ; MRIfree(&mri_in) ; mri_in = mri_tmp ; } /* make sure they are the same size */ if (mri_in->width != mri_ref->width || mri_in->height != mri_ref->height || mri_in->depth != mri_ref->depth) { int width, height, depth ; MRI *mri_tmp ; width = MAX(mri_in->width, mri_ref->width) ; height = MAX(mri_in->height, mri_ref->height) ; depth = MAX(mri_in->depth, mri_ref->depth) ; mri_tmp = MRIalloc(width, height, depth, MRI_UCHAR) ; MRIextractInto(mri_in, mri_tmp, 0, 0, 0, mri_in->width, mri_in->height, mri_in->depth, 0, 0, 0) ; #if 0 MRIfree(&mri_in) ; #else parms.mri_in = mri_in ; #endif mri_in = mri_orig = mri_tmp ; mri_tmp = MRIallocSequence(width, height,depth,MRI_UCHAR,mri_ref->nframes); MRIextractInto(mri_ref, mri_tmp, 0, 0, 0, mri_ref->width, mri_ref->height, mri_ref->depth, 0, 0, 0) ; #if 0 MRIfree(&mri_ref) ; #else parms.mri_in = mri_in ; #endif mri_ref = mri_tmp ; } if (!FZERO(tx) || !FZERO(ty) || !FZERO(tz)) { MRI *mri_tmp ; fprintf(stderr, "translating second volume by (%2.1f, %2.1f, %2.1f)\n", tx, ty, tz) ; mri_tmp = MRItranslate(mri_in, NULL, tx, ty, tz) ; MRIfree(&mri_in) ; mri_in = mri_tmp ; } if (!FZERO(rzrot)) { MRI *mri_tmp ; fprintf(stderr, "rotating second volume by %2.1f degrees around Z axis\n", (float)DEGREES(rzrot)) ; mri_tmp = MRIrotateZ_I(mri_in, NULL, rzrot) ; MRIfree(&mri_in) ; mri_in = mri_tmp ; } if (!FZERO(rxrot)) { MRI *mri_tmp ; fprintf(stderr, "rotating second volume by %2.1f degrees around X axis\n", (float)DEGREES(rxrot)) ; mri_tmp = MRIrotateX_I(mri_in, NULL, rxrot) ; MRIfree(&mri_in) ; mri_in = mri_tmp ; } if (!FZERO(ryrot)) { MRI *mri_tmp ; fprintf(stderr, "rotating second volume by %2.1f degrees around Y axis\n", (float)DEGREES(ryrot)) ; mri_tmp = MRIrotateY_I(mri_in, NULL, ryrot) ; MRIfree(&mri_in) ; mri_in = mri_tmp ; } if (!transform_loaded) /* wasn't preloaded */ parms.lta = LTAalloc(1, mri_in) ; if (!FZERO(blur_sigma)) { MRI *mri_kernel, *mri_tmp ; mri_kernel = MRIgaussian1d(blur_sigma, 100) ; mri_tmp = MRIconvolveGaussian(mri_in, NULL, mri_kernel) ; mri_in = mri_tmp ; MRIfree(&mri_kernel) ; } MRIscaleMeanIntensities(mri_in, mri_ref, mri_in); mri_ref_orig = mri_ref ; mri_in_orig = mri_in ; if (nreductions > 0) { mri_in_red = mri_in_tmp = MRIcopy(mri_in, NULL) ; mri_ref_red = mri_ref_tmp = MRIcopy(mri_ref, NULL) ; for (i = 0 ; i < nreductions ; i++) { mri_in_red = MRIreduceByte(mri_in_tmp, NULL) ; mri_ref_red = MRIreduceMeanAndStdByte(mri_ref_tmp,NULL); MRIfree(&mri_in_tmp); MRIfree(&mri_ref_tmp) ; mri_in_tmp = mri_in_red ; mri_ref_tmp = mri_ref_red ; } mri_in = mri_in_red ; mri_ref = mri_ref_red ; } /* for diagnostics */ if (full_res) { parms.mri_ref = mri_ref ; parms.mri_in = mri_in ; } else { parms.mri_ref = mri_ref_orig ; parms.mri_in = mri_in_orig ; } m_L = initialize_transform(mri_in, mri_ref, &parms) ; if (use_gradient) { MRI *mri_in_mag, *mri_ref_mag, *mri_grad, *mri_mag ; printf("computing gradient magnitude of input image...\n") ; mri_mag = MRIalloc(mri_in->width, mri_in->height, mri_in->depth,MRI_FLOAT); MRIcopyHeader(mri_in, mri_mag) ; mri_grad = MRIsobel(mri_in, NULL, mri_mag) ; MRIfree(&mri_grad) ; /* convert it to ubytes */ MRIvalScale(mri_mag, mri_mag, 0.0f, 255.0f) ; mri_in_mag = MRIclone(mri_in, NULL) ; MRIcopy(mri_mag, mri_in_mag) ; MRIfree(&mri_mag) ; /* now compute gradient of ref image */ printf("computing gradient magnitude of reference image...\n") ; mri_mag = MRIalloc(mri_ref->width, mri_ref->height, mri_ref->depth,MRI_FLOAT); MRIcopyHeader(mri_ref, mri_mag) ; mri_grad = MRIsobel(mri_ref, NULL, mri_mag) ; MRIfree(&mri_grad) ; /* convert it to ubytes */ MRIvalScale(mri_mag, mri_mag, 0.0f, 255.0f) ; mri_ref_mag = MRIclone(mri_ref, NULL) ; MRIcopy(mri_mag, mri_ref_mag) ; MRIfree(&mri_mag) ; register_mri(mri_in_mag, mri_ref_mag, &parms, m_L) ; MRIfree(&mri_in_mag) ; MRIfree(&mri_ref_mag) ; } register_mri(mri_in, mri_ref, &parms, m_L) ; if (check_crop_flag) /* not working yet! */ { printf("searching for cropped regions in the input image...\n") ; parms.mri_crop = find_cropping(mri_orig, mri_ref, &parms) ; MRIwrite(parms.mri_crop, "crop.mgh") ; register_mri(mri_in, mri_ref, &parms, m_L) ; } if (voxel_coords) { printf("transforming xform to voxel coordinates...\n") ; MRIrasXformToVoxelXform(mri_in_orig, mri_ref_orig, parms.lta->xforms[0].m_L, parms.lta->xforms[0].m_L); if (Gdiag & DIAG_WRITE) { MRI *mri_tmp ; mri_tmp = MRIlinearTransform(mri_in_orig, NULL,parms.lta->xforms[0].m_L); MRIwriteImageViews(mri_tmp, "morphed", IMAGE_SIZE) ; MRIfree(&mri_tmp) ; } } // save src and target info in lta getVolGeom(mri_in_orig, &parms.lta->xforms[0].src); getVolGeom(mri_ref_orig, &parms.lta->xforms[0].dst); fprintf(stderr, "writing output transformation to %s...\n", out_fname) ; if (invert_flag) { MATRIX *m_tmp ; m_tmp = MatrixInverse(parms.lta->xforms[0].m_L, NULL) ; MatrixFree(&parms.lta->xforms[0].m_L) ; // change src and dst getVolGeom(mri_in_orig, &parms.lta->xforms[0].dst); getVolGeom(mri_ref_orig, &parms.lta->xforms[0].src); parms.lta->xforms[0].m_L = m_tmp ; } // LTAwriteEx(parms.lta, out_fname) ; // if (mri_ref) MRIfree(&mri_ref) ; if (mri_in) MRIfree(&mri_in) ; msec = TimerStop(&start) ; seconds = nint((float)msec/1000.0f) ; minutes = seconds / 60 ; seconds = seconds % 60 ; fprintf(stderr, "registration took %d minutes and %d seconds.\n", minutes, seconds) ; exit(0) ; return(0) ; }