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 *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) ;
}
