int
main(int argc, char *argv[])
{
char *in_fname, *out_fname, **av, *xform_fname, fname[STRLEN] ;
MRI *mri_in, *mri_tmp ;
int ac, nargs, msec, minutes, seconds;
int input, ninputs ;
struct timeb start ;
TRANSFORM *transform = NULL ;
char cmdline[CMD_LINE_LEN], line[STRLEN], *cp, subject[STRLEN], sdir[STRLEN], base_name[STRLEN] ;
FILE *fp ;
make_cmd_version_string
(argc, argv,
"$Id: mri_fuse_intensity_images.c,v 1.2 2011/06/02 14:05:10 fischl Exp $",
"$Name: $", cmdline);
/* rkt: check for and handle version tag */
nargs = handle_version_option
(argc, argv,
"$Id: mri_fuse_intensity_images.c,v 1.2 2011/06/02 14:05:10 fischl Exp $",
"$Name: $");
if (nargs && argc - nargs == 1)
exit (0);
argc -= nargs;
setRandomSeed(-1L) ;
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 < 5)
ErrorExit
(ERROR_BADPARM,
"usage: %s [<options>] <longitudinal time point file> <in vol> <transform file> <out vol> \n",
Progname) ;
in_fname = argv[2] ;
xform_fname = argv[3] ;
out_fname = argv[4] ;
transform = TransformRead(xform_fname) ;
if (transform == NULL)
ErrorExit(ERROR_NOFILE, "%s: could not read transform from %s", Progname, xform_fname) ;
TimerStart(&start) ;
FileNamePath(argv[1], sdir) ;
cp = strrchr(sdir, '/') ;
if (cp)
{
strcpy(base_name, cp+1) ;
*cp = 0 ; // remove last component of path, which is base subject name
}
ninputs = 0 ;
fp = fopen(argv[1], "r") ;
if (fp == NULL)
ErrorExit(ERROR_NOFILE, "%s: could not read time point file %s", Progname, argv[1]) ;
do
{
cp = fgetl(line, STRLEN-1, fp) ;
if (cp != NULL && strlen(cp) > 0)
{
subjects[ninputs] = (char *)calloc(strlen(cp)+1, sizeof(char)) ;
strcpy(subjects[ninputs], cp) ;
ninputs++ ;
}
} while (cp != NULL && strlen(cp) > 0) ;
fclose(fp) ;
printf("processing %d timepoints in SUBJECTS_DIR %s...\n", ninputs, sdir) ;
for (input = 0 ; input < ninputs ; input++)
{
sprintf(subject, "%s.long.%s", subjects[input], base_name) ;
printf("reading subject %s - %d of %d\n", subject, input+1, ninputs) ;
sprintf(fname, "%s/%s/mri/%s", sdir, subject, in_fname) ;
mri_tmp = MRIread(fname) ;
if (!mri_tmp)
ErrorExit(ERROR_NOFILE, "%s: could not read input MR volume from %s",
Progname, fname) ;
MRImakePositive(mri_tmp, mri_tmp) ;
if (input == 0)
{
mri_in =
MRIallocSequence(mri_tmp->width, mri_tmp->height, mri_tmp->depth,
mri_tmp->type, ninputs) ;
if (!mri_in)
ErrorExit(ERROR_NOMEMORY,
"%s: could not allocate input volume %dx%dx%dx%d",
mri_tmp->width,mri_tmp->height,mri_tmp->depth,ninputs) ;
MRIcopyHeader(mri_tmp, mri_in) ;
}
if (mask_fname)
{
int i ;
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) ;
for (i = 1 ; i < WM_MIN_VAL ; i++)
MRIreplaceValues(mri_mask, mri_mask, i, 0) ;
MRImask(mri_tmp, mri_mask, mri_tmp, 0, 0) ;
MRIfree(&mri_mask) ;
}
MRIcopyFrame(mri_tmp, mri_in, 0, input) ;
MRIfree(&mri_tmp) ;
}
MRIaddCommandLine(mri_in, cmdline) ;
// try to bring the images closer to each other at each voxel where they seem to come from the same distribution
{
MRI *mri_frame1, *mri_frame2 ;
double rms_after ;
mri_frame1 = MRIcopyFrame(mri_in, NULL, 0, 0) ;
mri_frame2 = MRIcopyFrame(mri_in, NULL, 1, 0) ;
rms_after = MRIrmsDiff(mri_frame1, mri_frame2) ;
printf("RMS before intensity cohering = %2.2f\n", rms_after) ;
MRIfree(&mri_frame1) ; MRIfree(&mri_frame2) ;
if (0)
normalize_timepoints(mri_in, 2.0, cross_time_sigma) ;
else
normalize_timepoints_with_parzen_window(mri_in, cross_time_sigma) ;
mri_frame1 = MRIcopyFrame(mri_in, NULL, 0, 0) ;
mri_frame2 = MRIcopyFrame(mri_in, NULL, 1, 0) ;
rms_after = MRIrmsDiff(mri_frame1, mri_frame2) ;
MRIfree(&mri_frame1) ; MRIfree(&mri_frame2) ;
printf("RMS after intensity cohering = %2.2f (sigma=%2.2f)\n", rms_after, cross_time_sigma) ;
}
for (input = 0 ; input < ninputs ; input++)
{
sprintf(fname, "%s/%s.long.%s/mri/%s", sdir, subjects[input], base_name, out_fname) ;
printf("writing normalized volume to %s...\n", fname) ;
if (MRIwriteFrame(mri_in, fname, input) != NO_ERROR)
ErrorExit(ERROR_BADFILE, "%s: could not write normalized volume to %s",Progname, fname);
}
MRIfree(&mri_in) ;
printf("done.\n") ;
msec = TimerStop(&start) ;
seconds = nint((float)msec/1000.0f) ;
minutes = seconds / 60 ;
seconds = seconds % 60 ;
printf("normalization took %d minutes and %d seconds.\n",
minutes, seconds) ;
if (diag_fp)
fclose(diag_fp) ;
exit(0) ;
return(0) ;
}
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 *gca_fname, *in_fname, *out_fname, **av, *xform_fname, fname[STRLEN] ;
MRI *mri_in, *mri_norm = NULL, *mri_tmp, *mri_ctrl = NULL ;
GCA *gca ;
int ac, nargs, nsamples, msec, minutes, seconds;
int i, struct_samples, norm_samples = 0, n, input, ninputs ;
struct timeb start ;
GCA_SAMPLE *gcas, *gcas_norm = NULL, *gcas_struct ;
TRANSFORM *transform = NULL ;
char cmdline[CMD_LINE_LEN], line[STRLEN], *cp, subject[STRLEN], sdir[STRLEN], base_name[STRLEN] ;
FILE *fp ;
make_cmd_version_string
(argc, argv,
"$Id: mri_cal_normalize.c,v 1.2.2.1 2011/08/31 00:32:41 nicks Exp $",
"$Name: stable5 $", cmdline);
/* rkt: check for and handle version tag */
nargs = handle_version_option
(argc, argv,
"$Id: mri_cal_normalize.c,v 1.2.2.1 2011/08/31 00:32:41 nicks Exp $",
"$Name: stable5 $");
if (nargs && argc - nargs == 1)
exit (0);
argc -= nargs;
setRandomSeed(-1L) ;
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 < 6)
ErrorExit
(ERROR_BADPARM,
"usage: %s [<options>] <longitudinal time point file> <in vol> <atlas> <transform file> <out vol> \n",
Progname) ;
in_fname = argv[2] ;
gca_fname = argv[3] ;
xform_fname = argv[4] ;
out_fname = argv[5] ;
transform = TransformRead(xform_fname) ;
if (transform == NULL)
ErrorExit(ERROR_NOFILE, "%s: could not read transform from %s", Progname, xform_fname) ;
if (read_ctrl_point_fname)
{
mri_ctrl = MRIread(read_ctrl_point_fname) ;
if (mri_ctrl == NULL)
ErrorExit(ERROR_NOFILE, "%s: could not read precomputed control points from %s",
Progname, read_ctrl_point_fname) ;
}
TimerStart(&start) ;
printf("reading atlas from '%s'...\n", gca_fname) ;
fflush(stdout) ;
gca = GCAread(gca_fname) ;
if (gca == NULL)
ErrorExit(ERROR_NOFILE, "%s: could not open GCA %s.\n",Progname, gca_fname) ;
GCAregularizeConditionalDensities(gca, .5) ;
FileNamePath(argv[1], sdir) ;
cp = strrchr(sdir, '/') ;
if (cp)
{
strcpy(base_name, cp+1) ;
*cp = 0 ; // remove last component of path, which is base subject name
}
ninputs = 0 ;
fp = fopen(argv[1], "r") ;
if (fp == NULL)
ErrorExit(ERROR_NOFILE, "%s: could not read time point file %s", argv[1]) ;
do
{
cp = fgetl(line, STRLEN-1, fp) ;
if (cp != NULL && strlen(cp) > 0)
{
subjects[ninputs] = (char *)calloc(strlen(cp)+1, sizeof(char)) ;
strcpy(subjects[ninputs], cp) ;
ninputs++ ;
}
} while (cp != NULL && strlen(cp) > 0) ;
fclose(fp) ;
printf("processing %d timepoints in SUBJECTS_DIR %s...\n", ninputs, sdir) ;
for (input = 0 ; input < ninputs ; input++)
{
sprintf(subject, "%s.long.%s", subjects[input], base_name) ;
printf("reading subject %s - %d of %d\n", subject, input+1, ninputs) ;
sprintf(fname, "%s/%s/mri/%s", sdir, subject, in_fname) ;
mri_tmp = MRIread(fname) ;
if (!mri_tmp)
ErrorExit(ERROR_NOFILE, "%s: could not read input MR volume from %s",
Progname, fname) ;
MRImakePositive(mri_tmp, mri_tmp) ;
if (mri_tmp && ctrl_point_fname && !mri_ctrl)
{
mri_ctrl = MRIallocSequence(mri_tmp->width, mri_tmp->height,
mri_tmp->depth,MRI_FLOAT, nregions*2) ; // labels and means
MRIcopyHeader(mri_tmp, mri_ctrl) ;
}
if (input == 0)
{
mri_in =
MRIallocSequence(mri_tmp->width, mri_tmp->height, mri_tmp->depth,
mri_tmp->type, ninputs) ;
if (!mri_in)
ErrorExit(ERROR_NOMEMORY,
"%s: could not allocate input volume %dx%dx%dx%d",
mri_tmp->width,mri_tmp->height,mri_tmp->depth,ninputs) ;
MRIcopyHeader(mri_tmp, mri_in) ;
}
if (mask_fname)
{
int i ;
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) ;
for (i = 1 ; i < WM_MIN_VAL ; i++)
MRIreplaceValues(mri_mask, mri_mask, i, 0) ;
MRImask(mri_tmp, mri_mask, mri_tmp, 0, 0) ;
MRIfree(&mri_mask) ;
}
MRIcopyFrame(mri_tmp, mri_in, 0, input) ;
MRIfree(&mri_tmp) ;
}
MRIaddCommandLine(mri_in, cmdline) ;
GCAhistoScaleImageIntensitiesLongitudinal(gca, mri_in, 1) ;
{
int j ;
gcas = GCAfindAllSamples(gca, &nsamples, NULL, 1) ;
printf("using %d sample points...\n", nsamples) ;
GCAcomputeSampleCoords(gca, mri_in, gcas, nsamples, transform) ;
if (sample_fname)
GCAtransformAndWriteSamples
(gca, mri_in, gcas, nsamples, sample_fname, transform) ;
for (j = 0 ; j < 1 ; j++)
{
for (n = 1 ; n <= nregions ; n++)
{
for (norm_samples = i = 0 ; i < NSTRUCTURES ; i++)
{
if (normalization_structures[i] == Gdiag_no)
DiagBreak() ;
printf("finding control points in %s....\n",
cma_label_to_name(normalization_structures[i])) ;
gcas_struct = find_control_points(gca, gcas, nsamples, &struct_samples, n,
normalization_structures[i], mri_in, transform, min_prior,
ctl_point_pct) ;
discard_unlikely_control_points(gca, gcas_struct, struct_samples, mri_in, transform,
cma_label_to_name(normalization_structures[i])) ;
if (mri_ctrl && ctrl_point_fname) // store the samples
copy_ctrl_points_to_volume(gcas_struct, struct_samples, mri_ctrl, n-1) ;
if (i)
{
GCA_SAMPLE *gcas_tmp ;
gcas_tmp = gcas_concatenate(gcas_norm, gcas_struct, norm_samples, struct_samples) ;
free(gcas_norm) ;
norm_samples += struct_samples ;
gcas_norm = gcas_tmp ;
}
else
{
gcas_norm = gcas_struct ; norm_samples = struct_samples ;
}
}
printf("using %d total control points "
"for intensity normalization...\n", norm_samples) ;
if (normalized_transformed_sample_fname)
GCAtransformAndWriteSamples(gca, mri_in, gcas_norm, norm_samples,
normalized_transformed_sample_fname,
transform) ;
mri_norm = GCAnormalizeSamplesAllChannels(mri_in, gca, gcas_norm, file_only ? 0 :norm_samples,
transform, ctl_point_fname, bias_sigma) ;
if (Gdiag & DIAG_WRITE)
{
char fname[STRLEN] ;
sprintf(fname, "norm%d.mgz", n) ;
printf("writing normalized volume to %s...\n", fname) ;
MRIwrite(mri_norm, fname) ;
sprintf(fname, "norm_samples%d.mgz", n) ;
GCAtransformAndWriteSamples(gca, mri_in, gcas_norm, norm_samples,
fname, transform) ;
}
MRIcopy(mri_norm, mri_in) ; /* for next pass through */
MRIfree(&mri_norm) ;
}
}
}
// now do cross-time normalization to bring each timepoint closer to the mean at each location
{
MRI *mri_frame1, *mri_frame2, *mri_tmp ;
double rms_before, rms_after ;
int i ;
mri_tmp = MRIcopy(mri_in, NULL) ;
mri_frame1 = MRIcopyFrame(mri_in, NULL, 0, 0) ;
mri_frame2 = MRIcopyFrame(mri_in, NULL, 1, 0) ;
rms_before = MRIrmsDiff(mri_frame1, mri_frame2) ;
printf("RMS before = %2.2f\n", rms_before) ;
MRIfree(&mri_frame1) ; MRIfree(&mri_frame2) ;
for (i = 50 ; i <= 50 ; i += 25)
{
MRIcopy(mri_tmp, mri_in) ;
normalize_timepoints_with_samples(mri_in, gcas_norm, norm_samples, i) ;
mri_frame1 = MRIcopyFrame(mri_in, NULL, 0, 0) ;
mri_frame2 = MRIcopyFrame(mri_in, NULL, 1, 0) ;
rms_after = MRIrmsDiff(mri_frame1, mri_frame2) ;
MRIfree(&mri_frame1) ; MRIfree(&mri_frame2) ;
printf("RMS after (%d) = %2.2f\n", i, rms_after) ;
}
}
{
MRI *mri_frame1, *mri_frame2 ;
double rms_after ;
int i ;
mri_tmp = MRIcopy(mri_in, NULL) ;
for (i = 10 ; i <= 10 ; i += 10)
{
MRIcopy(mri_tmp, mri_in) ;
normalize_timepoints(mri_in, 2.0, i) ;
mri_frame1 = MRIcopyFrame(mri_in, NULL, 0, 0) ;
mri_frame2 = MRIcopyFrame(mri_in, NULL, 1, 0) ;
rms_after = MRIrmsDiff(mri_frame1, mri_frame2) ;
MRIfree(&mri_frame1) ; MRIfree(&mri_frame2) ;
printf("RMS after intensity cohering = %2.2f\n", rms_after) ;
}
}
for (input = 0 ; input < ninputs ; input++)
{
sprintf(fname, "%s/%s.long.%s/mri/%s", sdir, subjects[input], base_name, out_fname) ;
printf("writing normalized volume to %s...\n", fname) ;
if (MRIwriteFrame(mri_in, fname, input) != NO_ERROR)
ErrorExit(ERROR_BADFILE, "%s: could not write normalized volume to %s",Progname, fname);
}
if (ctrl_point_fname)
{
printf("writing control points to %s\n", ctrl_point_fname) ;
MRIwrite(mri_ctrl, ctrl_point_fname) ;
MRIfree(&mri_ctrl) ;
}
MRIfree(&mri_in) ;
printf("freeing GCA...") ;
if (gca)
GCAfree(&gca) ;
printf("done.\n") ;
msec = TimerStop(&start) ;
seconds = nint((float)msec/1000.0f) ;
minutes = seconds / 60 ;
seconds = seconds % 60 ;
printf("normalization took %d minutes and %d seconds.\n",
minutes, seconds) ;
if (diag_fp)
fclose(diag_fp) ;
exit(0) ;
return(0) ;
}
int
main(int argc, char *argv[]) {
char *gca_fname, *in_fname, **av, *xform_fname ;
MRI *mri_in, *mri_tmp, *mri_orig = NULL ;
GCA *gca ;
int ac, nargs, input, ninputs ;
TRANSFORM *transform = NULL ;
char cmdline[CMD_LINE_LEN] ;
double ll ;
make_cmd_version_string
(argc, argv,
"$Id: mri_log_likelihood.c,v 1.4 2011/03/02 00:04:22 nicks Exp $",
"$Name: stable5 $", cmdline);
/* rkt: check for and handle version tag */
nargs = handle_version_option
(argc, argv,
"$Id: mri_log_likelihood.c,v 1.4 2011/03/02 00:04:22 nicks Exp $",
"$Name: stable5 $");
if (nargs && argc - nargs == 1)
exit (0);
argc -= nargs;
setRandomSeed(-1L) ;
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 < 3)
ErrorExit
(ERROR_BADPARM,
"usage: %s [<options>] <inbrain1> <inbrain2> ... "
"<atlas> <transform file> ...\n",
Progname) ;
ninputs = (argc - 1) / 2 ;
if (DIAG_VERBOSE_ON)
printf("reading %d input volume%ss\n", ninputs, ninputs > 1 ? "s" : "") ;
in_fname = argv[1] ;
gca_fname = argv[1+ninputs] ;
xform_fname = argv[2+ninputs] ;
transform = TransformRead(xform_fname) ;
if (!transform)
ErrorExit(ERROR_NOFILE, "%s: could not read input transform from %s",
Progname, xform_fname) ;
if (DIAG_VERBOSE_ON)
printf("reading atlas from '%s'...\n", gca_fname) ;
gca = GCAread(gca_fname) ;
if (!gca)
ErrorExit(ERROR_NOFILE, "%s: could not read input atlas from %s",
Progname, gca_fname) ;
fflush(stdout) ;
for (input = 0 ; input < ninputs ; input++) {
in_fname = argv[1+input] ;
if (DIAG_VERBOSE_ON)
printf("reading input volume from %s...\n", in_fname) ;
mri_tmp = MRIread(in_fname) ;
if (!mri_tmp)
ErrorExit(ERROR_NOFILE, "%s: could not read input MR volume from %s",
Progname, in_fname) ;
MRImakePositive(mri_tmp, mri_tmp) ;
if (input == 0) {
mri_in =
MRIallocSequence(mri_tmp->width, mri_tmp->height, mri_tmp->depth,
mri_tmp->type, ninputs) ;
if (!mri_in)
ErrorExit(ERROR_NOMEMORY,
"%s: could not allocate input volume %dx%dx%dx%d",
mri_tmp->width,mri_tmp->height,mri_tmp->depth,ninputs) ;
MRIcopyHeader(mri_tmp, mri_in) ;
}
MRIcopyFrame(mri_tmp, mri_in, 0, input) ;
MRIfree(&mri_tmp) ;
}
MRIaddCommandLine(mri_in, cmdline) ;
TransformInvert(transform, mri_in) ;
if (orig_fname) {
mri_orig = MRIread(orig_fname) ;
if (mri_orig == NULL)
ErrorExit(ERROR_NOFILE, "%s: could not read orig volume from %s", Progname, orig_fname) ;
}
ll = GCAimageLogLikelihood(gca, mri_in, transform, 1, mri_orig) ;
printf("%2.0f\n", 10000*ll) ;
MRIfree(&mri_in) ;
if (gca)
GCAfree(&gca) ;
if (mri_in)
MRIfree(&mri_in) ;
exit(0) ;
return(0) ;
}
int
main(int argc, char *argv[]) {
char **av, *out_fname, *T1_fname, *PD_fname ;
int ac, nargs ;
MRI *mri_T1, *mri_PD, *mri_out, *mri_T2star = NULL ;
float TR, TE, alpha ;
char cmdline[CMD_LINE_LEN] ;
make_cmd_version_string (argc, argv, "$Id: mri_synthesize.c,v 1.18 2011/03/02 00:04:25 nicks Exp $", "$Name: $", cmdline);
/* rkt: check for and handle version tag */
nargs = handle_version_option (argc, argv, "$Id: mri_synthesize.c,v 1.18 2011/03/02 00:04:25 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 < 7)
usage_exit() ;
TR = atof(argv[1]) ;
alpha = atof(argv[2]) ;
TE = atof(argv[3]) ;
T1_fname = argv[4] ;
PD_fname = argv[5] ;
out_fname = argv[6] ;
printf("reading T1 volume from %s...\n", T1_fname) ;
mri_T1 = MRIread(T1_fname) ;
if (!mri_T1)
ErrorExit(ERROR_NOFILE, "%s: could not read T1 volume %s", Progname,
T1_fname) ;
if (extract) {
MRI *mri_tmp ;
int dx, dy, dz ;
dx = mri_T1->width/2 ;
dy = mri_T1->height/2 ;
dz = mri_T1->depth/2 ;
printf("extracting interior %dx%dx%d\n", dx, dy, dz) ;
mri_tmp = MRIextract(mri_T1, NULL, dx/2, dy/2, dz/2, dx, dy, dz) ;
MRIfree(&mri_T1) ;
mri_T1 = mri_tmp ;
}
if (jpdf_name) {
transform_T1_values_using_joint_pdf(mri_T1, jpdf_name, invert) ;
}
printf("reading PD volume from %s...\n", PD_fname) ;
mri_PD = MRIread(PD_fname) ;
if (!mri_PD)
ErrorExit(ERROR_NOFILE, "%s: could not read PD volume %s", Progname,
PD_fname) ;
if (T2star_fname != NULL) {
printf("reading T2* volume from %s...\n", T2star_fname) ;
mri_T2star = MRIread(T2star_fname) ;
if (!mri_T2star)
ErrorExit(ERROR_NOFILE, "%s: could not read T2* volume %s", Progname,
T2star_fname) ;
}
if (PDsat > 0)
saturate_PD(mri_PD, PDsat) ;
if (extract) {
MRI *mri_tmp ;
int dx, dy, dz ;
dx = mri_PD->width/2 ;
dy = mri_PD->height/2 ;
dz = mri_PD->depth/2 ;
mri_tmp = MRIextract(mri_PD, NULL, dx/2, dy/2, dz/2, dx, dy, dz) ;
MRIfree(&mri_PD) ;
mri_PD = mri_tmp ;
}
if (use_weighting) {
mri_out = MRIsynthesizeWeightedVolume(mri_T1, mri_PD, w5, TR, w30, TR, 110,TE);
} else {
printf("synthesizing volume with TR=%2.1f msec, TE=%2.1f msec, and alpha=%2.2f degrees...\n",
TR, TE, alpha) ;
if (normalize)
normalize_PD(mri_PD, 1000) ;
if (discard)
discard_PD(mri_PD, 250, 1500) ;
if (nl_remap_T1)
remap_T1(mri_T1, nl_mean, nl_scale) ;
if (nfaf > 0)
mri_out = MRIsynthesizeWithFAF(mri_T1, mri_PD, NULL, TR, RADIANS(alpha), TE, nfaf, faf_coefs) ;
else
mri_out = MRIsynthesize(mri_T1, mri_PD, mri_T2star, NULL, TR, RADIANS(alpha), TE) ;
}
if (nbias > 0)
apply_bias_field(mri_out, nbias, bias_coefs) ;
printf("writing output to %s.\n", out_fname) ;
MRIaddCommandLine(mri_out, cmdline) ;
MRIwrite(mri_out, out_fname) ;
exit(0) ;
return(0) ; /* for ansi */
}
int
main(int argc, char *argv[])
{
MRI *mri_src, *mri_dst, *mri_tmp, *mri_labeled, *mri_labels;
char *input_file_name, *output_file_name ;
int nargs, i, msec ;
struct timeb then ;
float white_mean, white_sigma, gray_mean, gray_sigma ;
char cmdline[CMD_LINE_LEN] ;
TAGmakeCommandLineString(argc, argv, cmdline) ;
/* rkt: check for and handle version tag */
nargs = handle_version_option
(argc, argv,
"$Id: mri_segment.c,v 1.40 2011/03/02 00:04:24 nicks Exp $",
"$Name: stable5 $");
if (nargs && argc - nargs == 1)
{
exit (0);
}
argc -= nargs;
Progname = argv[0] ;
DiagInit(NULL, NULL, NULL) ;
ErrorInit(NULL, NULL, NULL) ;
for ( ; argc > 1 && ISOPTION(*argv[1]) ; argc--, argv++)
{
nargs = get_option(argc, argv) ;
argc -= nargs ;
argv += nargs ;
}
if (argc < 3)
{
usage_exit(1);
}
TimerStart(&then) ;
input_file_name = argv[1] ;
output_file_name = argv[2] ;
mri_src = MRIread(input_file_name) ;
if (!mri_src)
ErrorExit(ERROR_NOFILE, "%s: could not read source volume from %s",
Progname, input_file_name) ;
MRIaddCommandLine(mri_src, cmdline) ;
if (mri_src->type != MRI_UCHAR)
{
MRI *mri_tmp ;
printf("changing input type from %d to UCHAR\n", mri_src->type) ;
mri_tmp = MRIchangeType(mri_src, MRI_UCHAR, 0, 1000, 1) ;
MRIfree(&mri_src) ;
mri_src = mri_tmp ;
}
if (thicken > 1)
{
mri_dst = MRIcopy(mri_src, NULL) ;
/* MRIfilterMorphology(mri_dst, mri_dst) ;*/
fprintf(stderr, "removing 1-dimensional structures...\n") ;
MRIremove1dStructures(mri_dst, mri_dst, 10000, 2, NULL) ;
#if 0
MRIcheckRemovals(mri_src, mri_dst, mri_labels, 5) ;
fprintf(stderr, "thickening thin strands....\n") ;
MRIthickenThinWMStrands(mri_src, mri_dst, mri_dst, thickness, nsegments,
wm_hi) ;
#endif
MRIwrite(mri_dst, output_file_name) ;
exit(0) ;
}
mri_labels = MRIclone(mri_src, NULL) ;
if (auto_detect_stats && !wm_low_set) /* widen range to allow
for more variability */
{
wm_low -= 10 ;
}
fprintf(stderr, "doing initial intensity segmentation...\n") ;
mri_tmp = MRIintensitySegmentation(mri_src, NULL, wm_low, wm_hi, gray_hi);
if (Gdiag & DIAG_WRITE && DIAG_VERBOSE_ON)
{
MRIwrite(mri_tmp, "tmp1.mgz") ;
}
fprintf(stderr, "using local statistics to label ambiguous voxels...\n") ;
MRIhistoSegment(mri_src, mri_tmp, wm_low, wm_hi, gray_hi, wsize, 3.0f) ;
if (Gdiag & DIAG_WRITE && DIAG_VERBOSE_ON)
{
MRIwrite(mri_tmp, "tmp2.mgz") ;
}
if (auto_detect_stats)
{
fprintf(stderr, "computing class statistics for intensity windows...\n") ;
MRIcomputeClassStatistics(mri_src, mri_tmp, gray_low, WHITE_MATTER_MEAN,
&white_mean, &white_sigma, &gray_mean,
&gray_sigma) ;
if (!finite(white_mean) || !finite(white_sigma) ||
!finite(gray_mean) || !finite(gray_sigma))
ErrorExit
(ERROR_BADPARM,
"%s: class statistics not finite - check input volume!",
Progname);
if (!wm_low_set)
{
if (FZERO(gray_sigma))
{
wm_low = (white_mean+gray_mean) / 2 ;
}
else
{
wm_low = gray_mean + gray_sigma ;
}
}
if (!gray_hi_set)
{
gray_hi = gray_mean + 2*gray_sigma ;
#if 1
if (gray_hi >= white_mean)
{
gray_hi = white_mean-1 ;
}
#endif
}
fprintf(stderr, "setting bottom of white matter range to %2.1f\n",wm_low);
fprintf(stderr, "setting top of gray matter range to %2.1f\n", gray_hi) ;
if (log_stats)
{
FILE *fp ;
fp = fopen("segment.dat", "w") ;
if (fp)
{
fprintf(fp, "WM: %2.1f +- %2.1f\n",white_mean, white_sigma) ;
fprintf(fp, "GM: %2.1f +- %2.1f\n",gray_mean, gray_sigma) ;
fprintf(fp, "setting bottom of white matter range to %2.1f\n",wm_low);
fprintf(fp, "setting top of gray matter range to %2.1f\n", gray_hi) ;
fclose(fp) ;
}
}
fprintf(stderr, "doing initial intensity segmentation...\n") ;
mri_tmp = MRIintensitySegmentation(mri_src, NULL, wm_low, wm_hi, gray_hi);
fprintf(stderr, "using local statistics to label ambiguous voxels...\n") ;
MRIhistoSegment(mri_src, mri_tmp, wm_low, wm_hi, gray_hi, wsize, 3.0f) ;
}
else
{
/* just some not-too-dopey defaults - won't really be used */
white_mean = 110 ;
white_sigma = 5.0 ;
gray_mean = 65 ;
gray_sigma = 12 ;
}
fprintf(stderr,
"using local geometry to label remaining ambiguous voxels...\n") ;
mri_labeled = MRIcpolvMedianCurveSegment(mri_src, mri_tmp, NULL, 5, 3,
gray_hi, wm_low);
fprintf(stderr,
"\nreclassifying voxels using Gaussian border classifier...\n") ;
/*
now use the gray and white matter border voxels to build a Gaussian
classifier at each point in space and reclassify all voxels in the
range [wm_low-5,gray_hi].
*/
for (i = 0 ; i < niter ; i++)
{
MRIreclassify(mri_src, mri_labeled, mri_labeled, wm_low-5,gray_hi,wsize);
}
MRIfree(&mri_tmp) ;
mri_dst = MRImaskLabels(mri_src, mri_labeled, NULL) ;
MRIfree(&mri_labeled) ;
MRIrecoverBrightWhite(mri_src, mri_dst,mri_dst,wm_low,wm_hi,white_sigma,.33);
fprintf(stderr,
"\nremoving voxels with positive offset direction...\n") ;
#if 0
MRIremoveWrongDirection(mri_dst, mri_dst, 3, wm_low-5, gray_hi, mri_labels) ;
#else
MRIremoveWrongDirection(mri_dst, mri_dst, 3, wm_low-5, gray_hi, NULL) ;
#endif
if (thicken)
{
/* MRIfilterMorphology(mri_dst, mri_dst) ;*/
fprintf(stderr, "removing 1-dimensional structures...\n") ;
MRIremove1dStructures(mri_dst, mri_dst, 10000, 2, mri_labels) ;
#if 0
MRIcheckRemovals(mri_src, mri_dst, mri_labels, 5) ;
#endif
fprintf(stderr, "thickening thin strands....\n") ;
MRIthickenThinWMStrands(mri_src, mri_dst, mri_dst, thickness, nsegments,
wm_hi) ;
}
mri_tmp = MRIfindBrightNonWM(mri_src, mri_dst) ;
MRIbinarize(mri_tmp, mri_tmp, WM_MIN_VAL, 255, 0) ;
MRImaskLabels(mri_dst, mri_tmp, mri_dst) ;
MRIfilterMorphology(mri_dst, mri_dst) ;
if (fill_bg)
{
fprintf(stderr, "filling basal ganglia....\n") ;
MRIfillBasalGanglia(mri_src, mri_dst) ;
}
if (fill_ventricles)
{
fprintf(stderr, "filling ventricles....\n") ;
MRIfillVentricles(mri_dst, mri_dst) ;
}
MRIfree(&mri_src) ;
msec = TimerStop(&then) ;
fprintf(stderr, "white matter segmentation took %2.1f minutes\n",
(float)msec/(1000.0f*60.0f));
fprintf(stderr, "writing output to %s...\n", output_file_name) ;
if (keep_edits)
{
MRI *mri_old ;
mri_old = MRIread(output_file_name) ;
if (!mri_old)
{
ErrorPrintf
(ERROR_NOFILE, "%s: could not read file %s to preserve edits",
Progname, output_file_name) ;
exit(1);
}
else
{
MRIcopyLabel(mri_old, mri_dst, WM_EDITED_ON_VAL) ;
MRIcopyLabel(mri_old, mri_dst, WM_EDITED_OFF_VAL) ;
MRIfree(&mri_old) ;
}
}
MRIwrite(mri_dst, output_file_name) ;
MRIfree(&mri_dst) ;
exit(0) ;
return(0) ;
}
