int
main(int argc, char *argv[]) {
char **av, *out_vol ;
int ac, nargs ;
MRI *mri_time1, *mri_time2, *mri_tmp, *mri_atrophy ;
TRANSFORM *transform1, *transform2 ;
/* rkt: check for and handle version tag */
nargs = handle_version_option (argc, argv, "$Id: mri_map_atrophy.c,v 1.4 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 (argc < 6)
usage_exit() ;
out_vol = argv[argc-1] ;
printf("reading volume from %s...\n", argv[1]) ;
mri_time1 = MRIread(argv[1]) ;
if (!mri_time1)
ErrorExit(ERROR_NOFILE, "%s: could not read MRI volume %s", Progname, argv[2]) ;
mri_time2 = MRIread(argv[2]) ;
if (!mri_time2)
ErrorExit(ERROR_NOFILE, "%s: could not read MRI volume %s", Progname, argv[2]) ;
transform1 = TransformRead(argv[3]) ;
if (!transform1)
ErrorExit(ERROR_NOFILE, "%s: could not read transform from %s", Progname, argv[3]) ;
transform2 = TransformRead(argv[4]) ;
if (!transform2)
ErrorExit(ERROR_NOFILE, "%s: could not read transform from %s", Progname, argv[4]) ;
mri_tmp = TransformApplyType(transform1, mri_time1, NULL, SAMPLE_NEAREST);
MRIfree(&mri_time1) ;
mri_time1 = mri_tmp ;
mri_tmp = TransformApplyType(transform2, mri_time2, NULL, SAMPLE_NEAREST);
MRIfree(&mri_time2) ;
mri_time2 = mri_tmp ;
mri_atrophy = make_atrophy_map(mri_time1, mri_time2, NULL, transform1, transform2, gray_labels, ngray, csf_labels, ncsf) ;
MRIwrite(mri_atrophy, out_vol) ;
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, "-version"))
print_version() ;
else if (!stricmp(option, "DEBUG_VOXEL"))
{
Gx = atoi(argv[2]) ;
Gy = atoi(argv[3]) ;
Gz = atoi(argv[4]) ;
nargs = 3 ;
printf("debugging voxel (%d, %d, %d)\n", Gx,Gy,Gz) ;
}
else if (!stricmp(option, "out_like") || !stricmp(option, "ol"))
{
out_like_fname = argv[2] ;
nargs = 1 ;
printf("shaping output to be like %s...\n", out_like_fname) ;
}
else if (!stricmp(option, "dilate"))
{
dilate = atoi(argv[2]) ;
nargs = 1 ;
printf("dilating output volume %d times before writing\n", dilate) ;
}
else if (!stricmp(option, "erode"))
{
erode = atoi(argv[2]) ;
nargs = 1 ;
printf("dilating output volume %d times before writing\n", erode) ;
}
else if (!stricmp(option, "exit_none_found"))
{
exit_none_found = 1;
printf("will exit status 1 if no labels found\n");
}
else switch (toupper(*option))
{
case 'S':
sigma = atof(argv[2]) ;
printf("applying sigma=%2.1f smoothing kernel after extraction...\n",
sigma) ;
nargs = 1 ;
break ;
case 'T':
xform_fname = argv[2] ;
printf("reading and applying transform %s...\n", xform_fname) ;
nargs = 1 ;
transform = TransformRead(xform_fname) ;
if (!transform)
ErrorExit(ERROR_NOFILE, "%s: could not read transform from %s",
Progname, xform_fname) ;
if (transform->type != MORPH_3D_TYPE)
lta = (LTA *)(transform->xform) ;
break ;
case 'V':
Gdiag_no = atoi(argv[2]) ;
nargs = 1 ;
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 *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) ;
}
/*----------------------------------------------------------------------
Parameters:
Description:
----------------------------------------------------------------------*/
static int
get_option(int argc, char *argv[])
{
int nargs = 0 ;
char *option ;
option = argv[1] + 1 ; /* past '-' */
if (!stricmp(option, "-help")||!stricmp(option, "-usage"))
{
usage_exit(0);
}
else if (!stricmp(option, "no1d"))
{
no1d = 1 ;
printf( "disabling 1d normalization...\n") ;
}
else if (!stricmp(option, "nonmax_suppress"))
{
nonmax_suppress = atoi(argv[2]) ;
printf( "%s nonmaximum suppression\n",
nonmax_suppress ? "using" : "disabling") ;
nargs = 1 ;
}
else if (!stricmp(option, "erode"))
{
erode = atoi(argv[2]) ;
printf("eroding interior of surface %d times\n", erode) ;
nargs = 1 ;
}
else if (!stricmp(option, "MASK"))
{
mask_fname = argv[2] ;
nargs = 1 ;
printf("using MR volume %s to mask input volume...\n", mask_fname) ;
}
else if (!stricmp(option, "GRAD"))
{
grad_thresh = atof(argv[2]) ;
nargs = 1 ;
printf("using gradient volume thresholded at %2.1f to prevent control points from crossing edges...\n", grad_thresh) ;
}
else if (!stricmp(option, "MASK_SIGMA"))
{
mask_sigma = atof(argv[2]) ;
mask_thresh = atof(argv[3]) ;
nargs = 1 ;
printf("smoothing input volume with sigma = %2.3f mm and thresholding at %2.0f for mask\n",
mask_sigma, mask_thresh) ;
nargs = 2 ;
}
else if (!stricmp(option, "MASK_ORIG"))
{
mask_orig_fname = argv[2] ;
mask_orig_thresh = atof(argv[3]) ;
nargs = 1 ;
printf("removing control points that are below %2.3f in %s\n",
mask_orig_thresh, mask_orig_fname) ;
nargs = 2 ;
}
else if (!stricmp(option, "SURFACE"))
{
if (nsurfs >= MAX_NORM_SURFACES)
{
ErrorExit(ERROR_NOMEMORY, "too many surfaces (%d) specified", nsurfs) ;
}
surface_fnames[nsurfs] = argv[2] ;
surface_xforms[nsurfs] = TransformRead(argv[3]) ;
surface_xform_fnames[nsurfs] = argv[3] ;
if (surface_xforms[nsurfs] == NULL)
{
ErrorExit(ERROR_NOFILE,
"%s:could not load xform from %s",Progname, argv[3]) ;
}
nargs = 2 ;
nsurfs++ ;
}
else if (!stricmp(option, "MIN_DIST"))
{
min_dist = atof(argv[2]) ;
nargs = 1 ;
printf("retaining %s points that are at least %2.3fmm from the boundary\n",
nonmax_suppress ? " nonmaximum suppressed" : "", min_dist) ;
}
else if (!stricmp(option, "INTERIOR"))
{
interior_fname1 = argv[2] ;
interior_fname2 = argv[3] ;
nargs = 2 ;
printf("using surfaces %s and %s to compute wm interior\n",
interior_fname1, interior_fname2) ;
}
else if (!stricmp(option, "MGH_MPRAGE") || !stricmp(option, "MPRAGE"))
{
scan_type = MRI_MGH_MPRAGE;
printf("assuming input volume is MGH (Van der Kouwe) MP-RAGE\n") ;
intensity_below = 15 ;
}
else if (!stricmp(option, "WASHU_MPRAGE"))
{
scan_type = MRI_WASHU_MPRAGE;
printf("assuming input volume is WashU MP-RAGE (dark GM)\n") ;
intensity_below = 22 ;
}
else if (!stricmp(option, "monkey"))
{
no1d = 1 ;
num_3d_iter = 1 ;
printf("disabling 1D normalization and "
"setting niter=1, make sure to use "
"-f to specify control points\n") ;
}
else if (!stricmp(option, "nosnr"))
{
nosnr = 1 ;
printf("disabling SNR normalization\n") ;
}
else if (!stricmp(option, "snr"))
{
nosnr = 0 ;
printf("enabling SNR normalization\n") ;
}
else if (!stricmp(option, "sigma"))
{
bias_sigma = atof(argv[2]) ;
nargs = 1 ;
printf("using Gaussian smoothing of bias field, sigma=%2.3f\n",
bias_sigma) ;
}
else if (!stricmp(option, "conform"))
{
conform = atoi(argv[1]) ;
nargs = 1 ;
printf(
"%sinterpolating and embedding volume to be 256^3...\n",
conform ? "": "not ") ;
}
else if (!stricmp(option, "noconform"))
{
conform = 0 ;
printf(
"%sinterpolating and embedding volume to be 256^3...\n",
conform ? "": "not ") ;
}
else if (!stricmp(option, "aseg") || !stricmp(option, "segmentation"))
{
aseg_fname = argv[2] ;
nargs = 1 ;
printf(
"using segmentation for initial intensity normalization\n") ;
}
else if (!stricmp(option, "gentle"))
{
gentle_flag = 1 ;
printf( "performing kinder gentler normalization...\n") ;
}
else if (!stricmp(option, "file_only") ||
!stricmp(option, "fonly") ||
!stricmp(option, "fileonly"))
{
file_only = 1 ;
control_point_fname = argv[2] ;
no1d = 1 ;
nargs = 1 ;
printf( "using control points from file %s...\n",
control_point_fname) ;
printf( "only using file control points...\n") ;
}
else switch (toupper(*option))
{
case 'D':
Gx = atoi(argv[2]) ;
Gy = atoi(argv[3]) ;
Gz = atoi(argv[4]) ;
nargs = 3 ;
printf("debugging voxel (%d, %d, %d)\n", Gx, Gy, Gz) ;
break ;
case 'V':
Gvx = atoi(argv[2]) ;
Gvy = atoi(argv[3]) ;
Gvz = atoi(argv[4]) ;
nargs = 3 ;
printf("debugging alternative voxel (%d, %d, %d)\n", Gvx, Gvy, Gvz) ;
break ;
case 'P':
prune = atoi(argv[2]) ;
nargs = 1 ;
printf("turning control point pruning %s\n", prune > 0 ? "on" : "off") ;
if (prune == 0)
{
prune = -1 ;
}
break ;
case 'R':
read_flag = 1 ;
nargs = 2 ;
control_volume_fname = argv[2] ;
bias_volume_fname = argv[3] ;
printf("reading bias field from %s and ctrl points from %s\n",
bias_volume_fname, control_volume_fname) ;
break ;
case 'L':
long_flag = 1 ;
no1d = 1 ;
nargs = 2 ;
long_control_volume_fname = argv[2] ;
long_bias_volume_fname = argv[3] ;
printf("reading bias field from %s and ctrl points from %s\n",
long_bias_volume_fname, long_control_volume_fname) ;
break ;
case 'W':
control_volume_fname = argv[2] ;
bias_volume_fname = argv[3] ;
nargs = 2 ;
printf("writing ctrl pts to %s\n", control_volume_fname) ;
printf("writing bias field to %s\n", bias_volume_fname) ;
break ;
case 'F':
control_point_fname = argv[2] ;
nargs = 1 ;
printf( "using control points from file %s...\n",
control_point_fname) ;
break ;
case 'A':
intensity_above = atof(argv[2]) ;
printf(
"using control point with intensity %2.1f above target.\n",
intensity_above) ;
nargs = 1 ;
break ;
case 'B':
intensity_below = atof(argv[2]) ;
printf(
"using control point with intensity %2.1f below target.\n",
intensity_below) ;
nargs = 1 ;
break ;
case 'G':
mni.max_gradient = atof(argv[2]) ;
printf( "using max gradient = %2.3f\n", mni.max_gradient) ;
nargs = 1 ;
break ;
#if 0
case 'V':
verbose = !verbose ;
break ;
#endif
case 'N':
num_3d_iter = atoi(argv[2]) ;
nargs = 1 ;
printf( "performing 3d normalization %d times\n", num_3d_iter) ;
break ;
case '?':
case 'U':
case 'H':
usage_exit(0) ;
break ;
default:
printf( "unknown option %s\n", argv[1]) ;
exit(1) ;
break ;
}
return(nargs) ;
}
static int
get_option(int argc, char *argv[])
{
int nargs = 0 ;
char *option ;
option = argv[1] + 1 ; /* past '-' */
StrUpper(option) ;
if (!stricmp(option, "debug_voxel"))
{
Gsx = Gx = atoi(argv[2]) ;
Gsy = Gy = atoi(argv[3]) ;
Gsz = Gz = atoi(argv[4]) ;
nargs = 3 ;
printf("debugging voxel (%d, %d, %d)\n", Gx, Gy, Gz) ;
}
else if (!stricmp(option, "debug_node"))
{
Gx = atoi(argv[2]) ;
Gy = atoi(argv[3]) ;
Gz = atoi(argv[4]) ;
nargs = 3 ;
printf("debugging node (%d, %d, %d)\n", Gx, Gy, Gz) ;
}
else if (!stricmp(option, "OPTIMAL"))
{
mp.integration_type = GCAM_INTEGRATE_OPTIMAL ;
printf("using optimal time-step integration\n") ;
}
else if (!stricmp(option, "NONEG")) {
mp.noneg = atoi(argv[2]) ;
nargs = 1 ;
printf("%s allowing temporary folds during numerical minimization\n",
mp.noneg ? "not" : "") ;
}
else if (!stricmp(option, "renormalize")) {
renormalize = atoi(argv[2]) ;
nargs = 1 ;
printf("%srenormalizing intensities\n", renormalize ? "" : "not ");
if (renormalize == 0)
{
match_mean_intensity = match_peak_intensity_ratio = 0 ;
}
}
else if (!stricmp(option, "aseg")) {
match_mean_intensity = match_peak_intensity_ratio = 0 ;
use_aseg = 1 ;
mp.l_dtrans = 1 ;
mp.l_log_likelihood = 0 ;
renormalize = 0 ;
printf("treating inputs as segmentations\n") ;
mp.dtrans_labels = dtrans_labels ;
mp.ndtrans = NDTRANS_LABELS ;
}
else if (!stricmp(option, "diag2")) {
mp.mri_diag2 = MRIread(argv[2]) ;
if (mp.mri_diag2 == NULL)
ErrorExit(ERROR_NOFILE, "%s: could not read diag volume from %s", Progname, argv[2]) ;
nargs = 1 ;
printf("writing d2 diagnostics for input volume %s\n", argv[2]) ;
}
else if (!stricmp(option, "MOMENTUM") || !stricmp(option, "FIXED"))
{
mp.integration_type = GCAM_INTEGRATE_FIXED ;
printf("using optimal time-step integration\n") ;
}
else if (!stricmp(option, "distance"))
{
distance = atof(argv[2]) ;
nargs = 1 ;
printf("expanding border by %2.1f mm every outer cycle\n", distance);
}
else if (!stricmp(option, "dtrans"))
{
mp.l_dtrans = atof(argv[2]) ;
nargs = 1 ;
printf("setting distance transform coefficient to %2.3f\n", mp.l_dtrans) ;
}
else if (!stricmp(option, "match_peak"))
{
match_peak_intensity_ratio = 1 ;
match_mean_intensity = 0 ;
printf("matching peak of intensity ratio histogram\n") ;
}
else if (!stricmp(option, "erode"))
{
erosions = atoi(argv[2]) ;
nargs = 1 ;
printf("eroding source and target image %d times before morphing\n",
erosions) ;
}
else if (!stricmp(option, "match_mean"))
{
match_peak_intensity_ratio = 0 ;
match_mean_intensity = atoi(argv[2]) ;
nargs = 1 ;
printf("%smatching peak of intensity ratio histogram\n",
match_mean_intensity ? "" : "not ") ;
}
else if (!stricmp(option, "intensity") ||!stricmp(option, "ll"))
{
mp.l_log_likelihood = atof(argv[2]) ;
nargs = 1 ;
printf("setting l_log_likelihood = %2.3f\n", mp.l_log_likelihood );
}
else if (!stricmp(option, "noregrid"))
{
regrid = 0 ;
mp.regrid = False ;
printf("disabling regridding...\n") ;
}
else if (!stricmp(option, "regrid"))
{
regrid = 1 ;
mp.regrid = True ;
printf("enabling regridding...\n") ;
}
else if (!stricmp(option, "view"))
{
Gsx = atoi(argv[2]) ;
Gsy = atoi(argv[3]) ;
Gsz = atoi(argv[4]) ;
nargs = 3 ;
printf("viewing voxel (%d, %d, %d)\n", Gsx, Gsy, Gsz) ;
}
else if (!stricmp(option, "LEVELS"))
{
mp.levels = atoi(argv[2]) ;
nargs = 1 ;
printf("levels = %d\n", mp.levels) ;
}
else if (!stricmp(option, "area_smoothness") || !stricmp(option, "asmooth"))
{
mp.l_area_smoothness = atof(argv[2]) ;
nargs = 1 ;
printf("using l_area_smoothness=%2.3f\n", mp.l_area_smoothness) ;
}
else if (!stricmp(option, "area"))
{
mp.l_area = atof(argv[2]) ;
nargs = 1 ;
printf("using l_area=%2.3f\n", mp.l_area) ;
}
else if (!stricmp(option, "area_intensity"))
{
mp.l_area_intensity = atof(argv[2]) ;
nargs = 1 ;
printf("using l_area_intensity=%2.3f\n", mp.l_area_intensity) ;
}
else if (!stricmp(option, "tol"))
{
mp.tol = atof(argv[2]) ;
nargs = 1 ;
printf("using tol=%2.3f\n", mp.tol) ;
}
else if (!stricmp(option, "sigma"))
{
mp.sigma = atof(argv[2]) ;
nargs = 1 ;
printf("using sigma=%2.3f\n", mp.sigma) ;
}
else if (!stricmp(option, "min_sigma"))
{
mp.min_sigma = atof(argv[2]) ;
nargs = 1 ;
printf("using min sigma=%2.3f\n", mp.min_sigma) ;
}
else if (!stricmp(option, "ribbon"))
{
ribbon_name = argv[2] ;
printf("reading ribbon from %s and inserting into aseg\n", ribbon_name) ;
nargs = 1 ;
}
else if (!stricmp(option, "rthresh"))
{
mp.ratio_thresh = atof(argv[2]) ;
mp.uncompress = 1 ;
nargs = 1 ;
printf("using compression ratio threshold = %2.3f...\n", mp.ratio_thresh) ;
}
else if (!stricmp(option, "scale"))
{
scale_values = atof(argv[2]) ;
nargs = 1 ;
printf("scaling input values by %2.3f\n", scale_values) ;
}
else if (!stricmp(option, "dt"))
{
mp.dt = atof(argv[2]) ;
nargs = 1 ;
printf("using dt = %2.3f\n", mp.dt) ;
}
else if (!stricmp(option, "passes"))
{
mp.npasses = atoi(argv[2]) ;
nargs = 1 ;
printf("integrating in %d passes (default=3)\n", mp.npasses) ;
}
else if (!stricmp(option, "skip"))
{
skip = atoi(argv[2]);
printf("skipping %d voxels in source data...\n", skip) ;
nargs = 1 ;
}
else if (!stricmp(option, "apply"))
{
apply_transform = atoi(argv[2]) ;
nargs = 1 ;
printf("%sapplying transform after registration\n", apply_transform ? "" : "not ") ;
}
else switch (*option)
{
case 'D':
mp.l_distance = atof(argv[2]) ;
nargs = 1 ;
printf("using l_distance = %2.3f\n", mp.l_distance) ;
break ;
case 'M':
mp.momentum = atof(argv[2]) ;
nargs = 1 ;
printf("momentum = %2.2f\n", mp.momentum) ;
break ;
case 'N':
mp.niterations = atoi(argv[2]) ;
nargs = 1 ;
printf("using niterations = %d\n", mp.niterations) ;
break ;
case 'S':
mp.l_smoothness = atof(argv[2]) ;
nargs = 1 ;
printf("using l_smoothness = %2.3f\n", mp.l_smoothness) ;
break ;
case 'T':
printf("reading transform from %s...\n", argv[2]) ;
transform = TransformRead(argv[2]) ;
if (transform == NULL)
ErrorExit(ERROR_NOFILE,"%s: could not read transform from %s\n",Progname,argv[2]);
nargs = 1 ;
if (transform->type == LINEAR_VOX_TO_VOX)
{
printf("converting transform to ras....\n") ;
LTAvoxelToRasXform((LTA *)(transform->xform), NULL, NULL) ;
}
break ;
case 'I':
printf("reading transform from %s...\n", argv[2]) ;
transform = TransformRead(argv[2]) ;
if (transform == NULL)
ErrorExit(ERROR_NOFILE,"%s: could not read transform from %s\n",Progname,argv[2]);
TransformInvert(transform, NULL) ;
TransformSwapInverse(transform) ;
if (transform->type == LINEAR_VOX_TO_VOX)
{
printf("converting transform to ras....\n") ;
LTAvoxelToRasXform((LTA *)(transform->xform), NULL, NULL) ;
}
nargs = 1 ;
break ;
case 'B':
mp.l_binary = atof(argv[2]) ;
nargs = 1 ;
printf("using l_binary=%2.3f\n", mp.l_binary) ;
break ;
case 'J':
mp.l_jacobian = atof(argv[2]) ;
nargs = 1 ;
printf("using l_jacobian=%2.3f\n", mp.l_jacobian) ;
break ;
case 'Z':
nozero = (atoi(argv[2]) == 0) ;
printf("%sdisabling zero image locations\n", nozero ? "" : "not ") ;
nargs = 1 ;
break ;
case 'A':
mp.navgs = atoi(argv[2]) ;
nargs = 1 ;
printf("smoothing gradient with %d averages...\n", mp.navgs) ;
break ;
case 'K':
mp.exp_k = atof(argv[2]) ;
printf("setting exp_k to %2.2f (default=%2.2f)\n",
mp.exp_k, EXP_K) ;
nargs = 1 ;
break ;
case 'W':
mp.write_iterations = atoi(argv[2]) ;
Gdiag |= DIAG_WRITE ;
nargs = 1 ;
printf("setting write iterations = %d\n", mp.write_iterations) ;
break ;
case '?':
case 'U':
usage_exit(1);
break ;
default:
printf("unknown option %s\n", argv[1]) ;
usage_exit(1) ;
break ;
}
return(nargs) ;
}
int
main(int argc, char *argv[]) {
TRANSFORM *transform = NULL ;
char **av, fname[STRLEN], *gca_fname, *subject_name, *cp ;
int ac, nargs, i, n ;
int msec, minutes, seconds, nsubjects ;
struct timeb start ;
GCA *gca ;
MRI *mri_parc, *mri_T1, *mri_PD ;
FILE *fp ;
/* rkt: check for and handle version tag */
nargs = handle_version_option (argc, argv, "$Id: mri_ca_tissue_parms.c,v 1.8 2011/03/02 00:04:14 nicks Exp $", "$Name: stable5 $");
if (nargs && argc - nargs == 1)
exit (0);
argc -= nargs;
Progname = argv[0] ;
ErrorInit(NULL, NULL, NULL) ;
DiagInit(NULL, NULL, NULL) ;
TimerStart(&start) ;
ac = argc ;
av = argv ;
for ( ; argc > 1 && ISOPTION(*argv[1]) ; argc--, argv++) {
nargs = get_option(argc, argv) ;
argc -= nargs ;
argv += nargs ;
}
if (!strlen(subjects_dir)) /* hasn't been set on command line */
{
cp = getenv("SUBJECTS_DIR") ;
if (!cp)
ErrorExit(ERROR_BADPARM, "%s: SUBJECTS_DIR not defined in environment",
Progname);
strcpy(subjects_dir, cp) ;
if (argc < 3)
usage_exit(1) ;
}
gca_fname = argv[1] ;
nsubjects = argc-2 ;
printf("computing average tissue parameters on %d subject\n",
nsubjects) ;
n = 0 ;
printf("reading GCA from %s...\n", gca_fname) ;
gca = GCAread(gca_fname) ;
for (i = 0 ; i < nsubjects ; i++) {
subject_name = argv[i+2] ;
printf("processing subject %s, %d of %d...\n", subject_name,i+1,
nsubjects);
sprintf(fname, "%s/%s/mri/%s", subjects_dir, subject_name, parc_dir) ;
if (DIAG_VERBOSE_ON)
printf("reading parcellation from %s...\n", fname) ;
mri_parc = MRIread(fname) ;
if (!mri_parc)
ErrorExit(ERROR_NOFILE, "%s: could not read parcellation file %s",
Progname, fname) ;
sprintf(fname, "%s/%s/mri/%s", subjects_dir, subject_name, T1_name) ;
if (DIAG_VERBOSE_ON)
printf("reading co-registered T1 from %s...\n", fname) ;
mri_T1 = MRIread(fname) ;
if (!mri_T1)
ErrorExit(ERROR_NOFILE, "%s: could not read T1 data from file %s",
Progname, fname) ;
sprintf(fname, "%s/%s/mri/%s", subjects_dir, subject_name, PD_name) ;
if (DIAG_VERBOSE_ON)
printf("reading co-registered T1 from %s...\n", fname) ;
mri_PD = MRIread(fname) ;
if (!mri_PD)
ErrorExit(ERROR_NOFILE, "%s: could not read PD data from file %s",
Progname, fname) ;
if (xform_name) {
/* VECTOR *v_tmp, *v_tmp2 ;*/
sprintf(fname, "%s/%s/mri/%s", subjects_dir, subject_name, xform_name) ;
printf("reading xform from %s...\n", fname) ;
transform = TransformRead(fname) ;
if (!transform)
ErrorExit(ERROR_NOFILE, "%s: could not read xform from %s",
Progname, fname) ;
#if 0
v_tmp = VectorAlloc(4,MATRIX_REAL) ;
*MATRIX_RELT(v_tmp,4,1)=1.0 ;
v_tmp2 = MatrixMultiply(lta->xforms[0].m_L, v_tmp, NULL) ;
printf("RAS (0,0,0) -->\n") ;
MatrixPrint(stdout, v_tmp2) ;
#endif
if (transform->type == LINEAR_RAS_TO_RAS) {
MATRIX *m_L ;
m_L = ((LTA *)transform->xform)->xforms[0].m_L ;
MRIrasXformToVoxelXform(mri_parc, mri_T1, m_L,m_L) ;
}
#if 0
v_tmp2 = MatrixMultiply(lta->xforms[0].m_L, v_tmp, v_tmp2) ;
printf("voxel (0,0,0) -->\n") ;
MatrixPrint(stdout, v_tmp2) ;
VectorFree(&v_tmp) ;
VectorFree(&v_tmp2) ;
test(mri_parc, mri_T1, mri_PD, lta->xforms[0].m_L) ;
#endif
}
if (histo_parms)
GCAhistogramTissueStatistics(gca,mri_T1,mri_PD,mri_parc,transform,histo_parms);
#if 0
else
GCAaccumulateTissueStatistics(gca, mri_T1, mri_PD, mri_parc, transform) ;
#endif
MRIfree(&mri_parc) ;
MRIfree(&mri_T1) ;
MRIfree(&mri_PD) ;
}
GCAnormalizeTissueStatistics(gca) ;
if (log_fname) {
printf("writing tissue parameters to %s\n", log_fname) ;
fp = fopen(log_fname, "w") ;
for (n = 1 ; n < MAX_GCA_LABELS ; n++) {
GCA_TISSUE_PARMS *gca_tp ;
gca_tp = &gca->tissue_parms[n] ;
if (gca_tp->total_training <= 0)
continue ;
fprintf(fp, "%d %f %f\n", n, gca_tp->T1_mean, gca_tp->PD_mean) ;
}
fclose(fp) ;
}
if (write_flag)
GCAwrite(gca, gca_fname) ;
GCAfree(&gca) ;
msec = TimerStop(&start) ;
seconds = nint((float)msec/1000.0f) ;
minutes = seconds / 60 ;
seconds = seconds % 60 ;
printf("tissue parameter statistic calculation took %d minutes"
" and %d seconds.\n", minutes, seconds) ;
exit(0) ;
return(0) ;
}
int
main(int argc, char *argv[]) {
char **av, fname[STRLEN], *out_fname, *subject_name, *cp ;
int ac, nargs, i, n, noint = 0, options ;
int msec, minutes, seconds, nsubjects, input ;
struct timeb start ;
GCA *gca ;
MRI *mri_seg, *mri_tmp, *mri_inputs ;
TRANSFORM *transform ;
LTA *lta;
GCA_BOUNDARY *gcab ;
Progname = argv[0] ;
ErrorInit(NULL, NULL, NULL) ;
DiagInit(NULL, NULL, NULL) ;
TimerStart(&start) ;
parms.use_gradient = 0 ;
spacing = 8 ;
/* rkt: check for and handle version tag */
nargs = handle_version_option
(argc, argv,
"$Id: mri_gcab_train.c,v 1.4 2011/03/16 20:23:33 fischl Exp $",
"$Name: $");
if (nargs && argc - nargs == 1)
exit (0);
argc -= nargs;
// parse command line args
ac = argc ;
av = argv ;
for ( ; argc > 1 && ISOPTION(*argv[1]) ; argc--, argv++) {
nargs = get_option(argc, argv) ;
argc -= nargs ;
argv += nargs ;
}
printf("reading gca from %s\n", argv[1]) ;
gca = GCAread(argv[1]) ;
if (!gca)
exit(Gerror) ;
if (!strlen(subjects_dir)) /* hasn't been set on command line */
{
cp = getenv("SUBJECTS_DIR") ;
if (!cp)
ErrorExit(ERROR_BADPARM, "%s: SUBJECTS_DIR not defined in environment",
Progname);
strcpy(subjects_dir, cp) ;
if (argc < 4)
usage_exit(1) ;
}
// options parsed. subjects and gca name remaining
out_fname = argv[argc-1] ;
nsubjects = argc-3 ;
for (options = i = 0 ; i < nsubjects ; i++) {
if (argv[i+1][0] == '-') {
nsubjects-- ;
options++ ;
}
}
printf("training on %d subject and writing results to %s\n",
nsubjects, out_fname) ;
n = 0 ;
gcab = GCABalloc(gca, 8, 0, 30, 10, target_label);
strcpy(gcab->gca_fname, argv[1]) ;
// going through the subject one at a time
for (nargs = i = 0 ; i < nsubjects+options ; i++) {
subject_name = argv[i+2] ;
//////////////////////////////////////////////////////////////
printf("***************************************"
"************************************\n");
printf("processing subject %s, %d of %d...\n", subject_name,i+1-nargs,
nsubjects);
if (stricmp(subject_name, "-NOINT") == 0) {
printf("not using intensity information for subsequent subjects...\n");
noint = 1 ;
nargs++ ;
continue ;
} else if (stricmp(subject_name, "-INT") == 0) {
printf("using intensity information for subsequent subjects...\n");
noint = 0 ;
nargs++ ;
continue ;
}
// reading this subject segmentation
sprintf(fname, "%s/%s/mri/%s", subjects_dir, subject_name, seg_dir) ;
if (Gdiag & DIAG_SHOW && DIAG_VERBOSE_ON)
fprintf(stderr, "Reading segmentation from %s...\n", fname) ;
mri_seg = MRIread(fname) ;
if (!mri_seg)
ErrorExit(ERROR_NOFILE, "%s: could not read segmentation file %s",
Progname, fname) ;
if ((mri_seg->type != MRI_UCHAR) && (mri_seg->type != MRI_FLOAT)) {
ErrorExit
(ERROR_NOFILE,
"%s: segmentation file %s is not type UCHAR or FLOAT",
Progname, fname) ;
}
if (binarize) {
int j ;
for (j = 0 ; j < 256 ; j++) {
if (j == binarize_in)
MRIreplaceValues(mri_seg, mri_seg, j, binarize_out) ;
else
MRIreplaceValues(mri_seg, mri_seg, j, 0) ;
}
}
if (insert_fname) {
MRI *mri_insert ;
sprintf(fname, "%s/%s/mri/%s",
subjects_dir, subject_name, insert_fname) ;
mri_insert = MRIread(fname) ;
if (mri_insert == NULL)
ErrorExit(ERROR_NOFILE,
"%s: could not read volume from %s for insertion",
Progname, insert_fname) ;
MRIbinarize(mri_insert, mri_insert, 1, 0, insert_label) ;
MRIcopyLabel(mri_insert, mri_seg, insert_label) ;
MRIfree(&mri_insert) ;
}
replaceLabels(mri_seg) ;
MRIeraseBorderPlanes(mri_seg, 1) ;
for (input = 0 ; input < gca->ninputs ; input++) {
//////////// set the gca type //////////////////////////////
// is this T1/PD training?
// how can we allow flash data training ???????
// currently checks the TE, TR, FA to be the same for all inputs
// thus we cannot allow flash data training.
////////////////////////////////////////////////////////////
sprintf(fname, "%s/%s/mri/%s",
subjects_dir, subject_name,input_names[input]);
if (DIAG_VERBOSE_ON)
printf("reading co-registered input from %s...\n", fname) ;
fprintf(stderr, " reading input %d: %s\n", input, fname);
mri_tmp = MRIread(fname) ;
if (!mri_tmp)
ErrorExit
(ERROR_NOFILE,
"%s: could not read image from file %s", Progname, fname) ;
// input check 1
if (getSliceDirection(mri_tmp) != MRI_CORONAL) {
ErrorExit
(ERROR_BADPARM,
"%s: must be in coronal direction, but it is not\n",
fname);
}
// input check 2
if (mri_tmp->xsize != 1 || mri_tmp->ysize != 1 || mri_tmp->zsize != 1) {
ErrorExit
(ERROR_BADPARM,
"%s: must have 1mm voxel size, but have (%f, %f, %f)\n",
fname, mri_tmp->xsize, mri_tmp->ysize, mri_tmp->ysize);
}
// input check 3 is removed. now we can handle c_(ras) != 0 case
// input check 4
if (i == 0) {
TRs[input] = mri_tmp->tr ;
FAs[input] = mri_tmp->flip_angle ;
TEs[input] = mri_tmp->te ;
} else if (!FEQUAL(TRs[input],mri_tmp->tr) ||
!FEQUAL(FAs[input],mri_tmp->flip_angle) ||
!FEQUAL(TEs[input], mri_tmp->te))
ErrorExit
(ERROR_BADPARM,
"%s: subject %s input volume %s: sequence parameters "
"(%2.1f, %2.1f, %2.1f)"
"don't match other inputs (%2.1f, %2.1f, %2.1f)",
Progname, subject_name, fname,
mri_tmp->tr, DEGREES(mri_tmp->flip_angle), mri_tmp->te,
TRs[input], DEGREES(FAs[input]), TEs[input]) ;
// first time do the following
if (input == 0) {
int nframes = gca->ninputs ;
///////////////////////////////////////////////////////////
mri_inputs =
MRIallocSequence(mri_tmp->width, mri_tmp->height, mri_tmp->depth,
mri_tmp->type, nframes) ;
if (!mri_inputs)
ErrorExit
(ERROR_NOMEMORY,
"%s: could not allocate input volume %dx%dx%dx%d",
mri_tmp->width, mri_tmp->height, mri_tmp->depth,nframes) ;
MRIcopyHeader(mri_tmp, mri_inputs) ;
}
// -mask option ////////////////////////////////////////////
if (mask_fname)
{
MRI *mri_mask ;
sprintf(fname, "%s/%s/mri/%s",
subjects_dir, subject_name, mask_fname);
printf("reading volume %s for masking...\n", fname) ;
mri_mask = MRIread(fname) ;
if (!mri_mask)
ErrorExit(ERROR_NOFILE, "%s: could not open mask volume %s.\n",
Progname, fname) ;
MRImask(mri_tmp, mri_mask, mri_tmp, 0, 0) ;
MRIfree(&mri_mask) ;
}
MRIcopyFrame(mri_tmp, mri_inputs, 0, input) ;
MRIfree(&mri_tmp) ;
}// end of inputs per subject
/////////////////////////////////////////////////////////
// xform_name is given, then we can use the consistent c_(r,a,s) for gca
/////////////////////////////////////////////////////////
if (xform_name)
{
// we read talairach.xfm which is a RAS-to-RAS
sprintf(fname, "%s/%s/mri/transforms/%s",
subjects_dir, subject_name, xform_name) ;
if (Gdiag & DIAG_SHOW && DIAG_VERBOSE_ON)
printf("INFO: reading transform file %s...\n", fname);
if (!FileExists(fname))
{
fprintf(stderr,"ERROR: cannot find transform file %s\n",fname);
exit(1);
}
transform = TransformRead(fname);
if (!transform)
ErrorExit(ERROR_NOFILE, "%s: could not read transform from file %s",
Progname, fname);
modify_transform(transform, mri_inputs, gca);
// Here we do 2 things
// 1. modify gca direction cosines to
// that of the transform destination (both linear and non-linear)
// 2. if ras-to-ras transform,
// then change it to vox-to-vox transform (linear case)
// modify transform to store inverse also
TransformInvert(transform, mri_inputs) ;
// verify inverse
lta = (LTA *) transform->xform;
}
else
{
GCAreinit(mri_inputs, gca);
// just use the input value, since dst = src volume
transform = TransformAlloc(LINEAR_VOXEL_TO_VOXEL, NULL) ;
}
////////////////////////////////////////////////////////////////////
// train gca
////////////////////////////////////////////////////////////////////
// segmentation is seg volume
// inputs is the volumes of all inputs
// transform is for this subject
// noint is whether to use intensity information or not
GCABtrain(gcab, mri_inputs, mri_seg, transform, target_label) ;
MRIfree(&mri_seg) ;
MRIfree(&mri_inputs) ;
TransformFree(&transform) ;
}
GCABcompleteTraining(gcab) ;
if (smooth > 0) {
printf("regularizing conditional densities with smooth=%2.2f\n", smooth) ;
GCAregularizeConditionalDensities(gca, smooth) ;
}
if (navgs) {
printf("applying mean filter %d times to conditional densities\n", navgs) ;
GCAmeanFilterConditionalDensities(gca, navgs) ;
}
printf("writing trained GCAB to %s...\n", out_fname) ;
if (GCABwrite(gcab, out_fname) != NO_ERROR)
ErrorExit
(ERROR_BADFILE, "%s: could not write gca to %s", Progname, out_fname) ;
if (Gdiag & DIAG_WRITE && DIAG_VERBOSE_ON)
{
MRI *mri ;
mri = GCAbuildMostLikelyVolume(gca, NULL) ;
MRIwrite(mri, "m.mgz") ;
MRIfree(&mri) ;
}
if (histo_fname) {
FILE *fp ;
int histo_counts[10000], xn, yn, zn, max_count ;
GCA_NODE *gcan ;
memset(histo_counts, 0, sizeof(histo_counts)) ;
fp = fopen(histo_fname, "w") ;
if (!fp)
ErrorExit(ERROR_BADFILE, "%s: could not open histo file %s",
Progname, histo_fname) ;
max_count = 0 ;
for (xn = 0 ; xn < gca->node_width; xn++) {
for (yn = 0 ; yn < gca->node_height ; yn++) {
for (zn = 0 ; zn < gca->node_depth ; zn++) {
gcan = &gca->nodes[xn][yn][zn] ;
if (gcan->nlabels < 1)
continue ;
if (gcan->nlabels == 1 && IS_UNKNOWN(gcan->labels[0]))
continue ;
histo_counts[gcan->nlabels]++ ;
if (gcan->nlabels > max_count)
max_count = gcan->nlabels ;
}
}
}
max_count = 20 ;
for (xn = 1 ; xn < max_count ; xn++)
fprintf(fp, "%d %d\n", xn, histo_counts[xn]) ;
fclose(fp) ;
}
GCAfree(&gca) ;
msec = TimerStop(&start) ;
seconds = nint((float)msec/1000.0f) ;
minutes = seconds / 60 ;
seconds = seconds % 60 ;
printf("classifier array training took %d minutes"
" and %d seconds.\n", minutes, seconds) ;
exit(0) ;
return(0) ;
}
int main(int argc, char *argv[])
{
char **av, *ltafn1, *ltafn2, *ltafn_total;
LTA *lta1, *lta2, *lta_total;
FILE *fo;
MATRIX *r_to_i_1, *i_to_r_1, *i_to_r_2, *r_to_i_2;
MATRIX *RAS_1_to_1, *RAS_2_to_2, *m_tmp;
int nargs, ac;
int type = 0;
Progname = argv[0];
nargs = handle_version_option
(argc, argv,
"$Id: mri_concatenate_lta.c,v 1.10 2011/03/16 21:23:48 nicks Exp $",
"$Name: stable5 $");
if (nargs && argc - nargs == 1)
{
exit (0);
}
argc -= nargs ;
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(1);
}
ltafn1 = argv[1];
ltafn2 = argv[2];
ltafn_total = argv[3];
printf("Read individual LTAs\n");
//lta1 = ltaReadFileEx(ltafn1);
TRANSFORM * trans = TransformRead(ltafn1);
lta1 = (LTA *)trans->xform ;
if (!lta1)
{
ErrorExit(ERROR_BADFILE, "%s: can't read file %s",Progname, ltafn1);
}
if (invert1)
{
VOL_GEOM vgtmp;
LT *lt;
MATRIX *m_tmp = lta1->xforms[0].m_L ;
lta1->xforms[0].m_L = MatrixInverse(lta1->xforms[0].m_L, NULL) ;
MatrixFree(&m_tmp) ;
lt = <a1->xforms[0];
if (lt->dst.valid == 0 || lt->src.valid == 0)
{
fprintf
(stderr,
"WARNING:********************************************************\n");
fprintf
(stderr,
"WARNING:dst or src volume is invalid. Inverse likely wrong.\n");
fprintf
(stderr,
"WARNING:********************************************************\n");
}
copyVolGeom(<->dst, &vgtmp);
copyVolGeom(<->src, <->dst);
copyVolGeom(&vgtmp, <->src);
}
if (strcmp(ltafn2,"identity.nofile") == 0)
{
type = TransformFileNameType(ltafn_total);
if (type == MNI_TRANSFORM_TYPE)
{
ltaMNIwrite(lta1, ltafn_total);
}
else
{
//change type to VOXEL_VOXEL
if (lta1->type != out_type)
{
LTAchangeType(lta1, out_type);
}
printf("Writing LTA to file %s...\n", ltafn_total);
fo = fopen(ltafn_total,"w");
if (fo==NULL)
ErrorExit(ERROR_BADFILE,
"%s: can't create file %s",Progname, ltafn_total);
LTAprint(fo, lta1);
fclose(fo);
}
LTAfree(<a1);
printf("%s successful.\n", Progname);
return 0;
}
type = TransformFileNameType(ltafn2);
if (type == MNI_TRANSFORM_TYPE)
{
if (invert2 != 0)
ErrorExit
(ERROR_BADFILE,
"%s: LTA2 is talairach.xfm, and shouldn't be inverted ",
Progname);
lta2 = ltaMNIreadEx(ltafn2) ;
//the talairach xform is supposed to be linear_RAS_TO_RAS, right? Yes
lta2->type = LINEAR_RAS_TO_RAS;
if (tal_src_file == 0 && lta2->xforms[0].src.valid == 0)
ErrorExit
(ERROR_BADFILE,
"%s: pls use -tal option to give talairach src and "
"template filenames",Progname);
if (tal_dst_file == 0 && lta2->xforms[0].dst.valid == 0)
ErrorExit
(ERROR_BADFILE,
"%s: pls use -tal option to give talairach src and "
"template filenames",Progname);
if (tal_src_file != 0)
{
LTAmodifySrcDstGeom(lta2, tal_src, NULL); // add src and dst information
}
if (tal_dst_file != 0)
{
LTAmodifySrcDstGeom(lta2, NULL, tal_dst); // add src and dst information
}
}
else
{
TRANSFORM * trans = TransformRead(ltafn2);
lta2 = (LTA *)trans->xform ;
//lta2 = ltaReadFileEx(ltafn2);
}
if (!lta2)
{
ErrorExit(ERROR_BADFILE, "%s: can't read file %s",Progname, ltafn2);
}
if (invert2)
{
VOL_GEOM vgtmp;
LT *lt;
MATRIX *m_tmp = lta2->xforms[0].m_L ;
lta2->xforms[0].m_L = MatrixInverse(lta2->xforms[0].m_L, NULL) ;
MatrixFree(&m_tmp) ;
lt = <a2->xforms[0];
if (lt->dst.valid == 0 || lt->src.valid == 0)
{
fprintf
(stderr,
"WARNING:********************************************************\n");
fprintf
(stderr,
"WARNING:dst or src volume is invalid. Inverse likely wrong.\n");
fprintf
(stderr,
"WARNING:********************************************************\n");
}
copyVolGeom(<->dst, &vgtmp);
copyVolGeom(<->src, <->dst);
copyVolGeom(&vgtmp, <->src);
}
if (vg_isEqual(<a1->xforms[0].dst, <a2->xforms[0].src) == 0)
{
/* ErrorExit(ERROR_BADFILE,
"%s: dst volume of lta1 doesn't match src
volume of lta2",Progname);*/
printf("Warning: dst volume of lta1 doesn't match src volume of lta2\n");
printf("Volume geometry for lta1-dst: \n");
vg_print(<a1->xforms[0].dst);
printf("Volume geometry for lta2-src:\n");
vg_print(<a2->xforms[0].src);
}
printf("Combining the two LTAs to get a RAS-to-RAS from src "
"of LTA1 to dst of LTA2...\n");
if (lta1->type == LINEAR_RAS_TO_RAS)
{
RAS_1_to_1 = MatrixCopy(lta1->xforms[0].m_L, NULL);
}
else if (lta1->type == LINEAR_VOX_TO_VOX)
{
r_to_i_1 = vg_r_to_i(<a1->xforms[0].src);
i_to_r_1 = vg_i_to_r(<a1->xforms[0].dst);
if (!r_to_i_1 || !i_to_r_1)
ErrorExit(ERROR_BADFILE,
"%s: failed to convert LTA1 to RAS_to_RAS",Progname);
m_tmp = MatrixMultiply(lta1->xforms[0].m_L, r_to_i_1, NULL);
RAS_1_to_1 = MatrixMultiply(i_to_r_1, m_tmp, NULL);
MatrixFree(&m_tmp);
}
else
{
ErrorExit(ERROR_BADFILE,
"%s: unknown transform type for LTA1",Progname);
}
if (lta2->type == LINEAR_RAS_TO_RAS)
{
RAS_2_to_2 = MatrixCopy(lta2->xforms[0].m_L, NULL);
}
else if (lta2->type == LINEAR_VOX_TO_VOX)
{
r_to_i_2 = vg_r_to_i(<a2->xforms[0].src);
i_to_r_2 = vg_i_to_r(<a2->xforms[0].dst);
if (!r_to_i_2 || !i_to_r_2)
ErrorExit(ERROR_BADFILE,
"%s: failed to convert LTA1 to RAS_to_RAS",Progname);
m_tmp = MatrixMultiply(lta2->xforms[0].m_L, r_to_i_2, NULL);
RAS_2_to_2 = MatrixMultiply(i_to_r_2, m_tmp, NULL);
MatrixFree(&m_tmp);
}
else
{
ErrorExit(ERROR_BADFILE, "%s: unknown transform type for LTA1",Progname);
}
lta_total = LTAalloc(1, NULL);
lta_total->type = LINEAR_RAS_TO_RAS;
MatrixMultiply(RAS_2_to_2, RAS_1_to_1, lta_total->xforms[0].m_L);
lta_total->xforms[0].src = lta1->xforms[0].src;
lta_total->xforms[0].dst = lta2->xforms[0].dst;
lta_total->xforms[0].x0 = 0;
lta_total->xforms[0].y0 = 0;
lta_total->xforms[0].z0 = 0;
lta_total->xforms[0].sigma = 1.0f;
type = TransformFileNameType(ltafn_total);
if (type == MNI_TRANSFORM_TYPE)
{
ltaMNIwrite(lta_total, ltafn_total);
}
else
{
//change type to VOXEL_VOXEL
if (lta_total->type != out_type)
{
LTAchangeType(lta_total, out_type);
}
printf("Writing combined LTA to file %s...\n", ltafn_total);
fo = fopen(ltafn_total,"w");
if (fo==NULL)
ErrorExit(ERROR_BADFILE,
"%s: can't create file %s",Progname, ltafn_total);
LTAprint(fo, lta_total);
fclose(fo);
}
LTAfree(<a1);
LTAfree(<a2);
LTAfree(<a_total);
MatrixFree(&RAS_1_to_1);
MatrixFree(&RAS_2_to_2);
if (tal_src)
{
MRIfree(&tal_src);
}
if (tal_dst)
{
MRIfree(&tal_dst);
}
printf("%s successful.\n", Progname);
return(0);
} /* end main() */
int
main(int argc, char *argv[]) {
char **av ;
int ac, nargs ;
MRI *mri_orig, *mri_norm, *mri_bias ;
int msec, minutes, seconds ;
struct timeb start ;
/* rkt: check for and handle version tag */
nargs = handle_version_option
(argc, argv,
"$Id: mri_apply_bias.c,v 1.5 2011/03/02 00:04:13 nicks Exp $",
"$Name: stable5 $");
if (nargs && argc - nargs == 1)
exit (0);
argc -= nargs;
Progname = argv[0] ;
ErrorInit(NULL, NULL, NULL) ;
DiagInit(NULL, NULL, NULL) ;
TimerStart(&start) ;
ac = argc ;
av = argv ;
for ( ; argc > 1 && ISOPTION(*argv[1]) ; argc--, argv++) {
nargs = get_option(argc, argv) ;
argc -= nargs ;
argv += nargs ;
}
if (argc < 4)
usage_exit(1) ;
mri_orig = MRIread(argv[1]) ;
if (mri_orig == NULL)
ErrorExit(ERROR_NOFILE, "%s: could not read %s",Progname, argv[1]) ;
mri_bias = MRIread(argv[2]) ;
if (mri_bias == NULL)
ErrorExit(ERROR_NOFILE, "%s: could not read %s",Progname, argv[2]) ;
if (xform_fname)
{
TRANSFORM *transform ;
MRI *mri ;
transform = TransformRead(xform_fname) ;
if (transform == NULL)
ErrorExit(ERROR_NOFILE, "%s: could not load transform %s", Progname, xform_fname) ;
mri = MRIcloneDifferentType(mri_orig, MRI_FLOAT) ;
TransformApplyInverse(transform, mri_bias, mri) ;
MRIfree(&mri_bias) ; mri_bias = mri ;
}
mri_norm = apply_bias(mri_orig, NULL, mri_bias);
fprintf(stderr, "writing to %s...\n", argv[3]) ;
MRIwrite(mri_norm, argv[3]) ;
MRIfree(&mri_norm) ;
msec = TimerStop(&start) ;
seconds = nint((float)msec/1000.0f) ;
minutes = seconds / 60 ;
seconds = seconds % 60 ;
fprintf(stderr, "bias correction took %d minutes and %d seconds.\n",
minutes, seconds) ;
exit(0) ;
return(0) ;
}
int
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, *xform_name, *out_fname, fname[STRLEN], *seg_name, *s1, *s2 ;
int ac, nargs, i, nsubjects, j, nvoxels ;
MRI *mri_seg[MAX_SUBJECTS] ;
float overlap, total_overlap ;
TRANSFORM *transform1, *transform2 ;
FILE *fp ;
/* rkt: check for and handle version tag */
nargs = handle_version_option (argc, argv, "$Id: mri_evaluate_morph.c,v 1.5 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) ;
if (strlen(sdir) == 0) {
char *cp ;
cp = getenv("SUBJECTS_DIR") ;
if (!cp)
ErrorExit(ERROR_BADPARM, "%s: no SUBJECTS_DIR in envoronment.\n",Progname);
strcpy(sdir, cp) ;
}
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() ;
xform_name = argv[1] ;
seg_name = argv[2] ;
out_fname = argv[argc-1] ;
#define FIRST_SUBJECT 3
nsubjects = argc-(FIRST_SUBJECT+1) ;
printf("processing %d subjects...\n", nsubjects) ;
for (i = FIRST_SUBJECT ; i < argc-1 ; i++) {
fprintf(stderr, "processing subject %s...\n", argv[i]) ;
sprintf(fname, "%s/%s/mri/%s", sdir, argv[i], seg_name) ;
mri_seg[i-FIRST_SUBJECT] = MRIread(fname) ;
if (!mri_seg[i-FIRST_SUBJECT])
ErrorExit(ERROR_NOFILE, "%s: could not read segmentation %s",
Progname, fname) ;
}
fp = fopen(out_fname, "w") ;
if (!fp)
ErrorExit(ERROR_NOFILE, "%s: could not open output file %s...\n", out_fname) ;
nvoxels = mri_seg[0]->width * mri_seg[0]->height * mri_seg[0]->depth ;
for (total_overlap = 0.0f, i = 0 ; i < nsubjects ; i++) {
for (j = i+1 ; j < nsubjects ; j++) {
s1 = argv[i+FIRST_SUBJECT] ;
s2 = argv[j+FIRST_SUBJECT] ;
printf("reading transforms for subjects %s and %s...\n", s1, s2) ;
sprintf(fname, "%s/%s/mri/transforms/%s", sdir, s1, xform_name) ;
transform1 = TransformRead(fname) ;
if (transform1 == NULL)
ErrorExit(ERROR_NOFILE, "%s: could not read transform %s",
Progname, fname) ;
sprintf(fname, "%s/%s/mri/transforms/%s", sdir, s1, xform_name) ;
transform2 = TransformRead(fname) ;
if (transform2 == NULL)
ErrorExit(ERROR_NOFILE, "%s: could not read transform %s",
Progname, fname) ;
printf("computing overlap for subjects %s and %s...\n", s1, s2) ;
overlap = compute_overlap(mri_seg[i], mri_seg[j], transform1, transform2) ;
total_overlap += overlap ;
printf("overlap = %2.0f, total = %2.0f\n", overlap, total_overlap) ;
fprintf(fp, "%s %s %2.0f %2.1f\n", s1, s2, overlap, 100.0f*overlap/(float)nvoxels) ;
fflush(fp) ;
TransformFree(&transform1) ;
TransformFree(&transform2) ;
}
}
total_overlap /= (float)((nsubjects*(nsubjects-1))/2.0f) ;
printf("overlap/subject pair = %2.0f (%2.1f %%)\n", total_overlap,
100.0f*total_overlap/(float)nvoxels) ;
fclose(fp) ;
exit(0) ;
return(0) ; /* for ansi */
}
int
main(int argc, char *argv[])
{
char **av, fname[STRLEN], *out_fname, *subject_name, *cp, *tp1_name, *tp2_name ;
char s1_name[STRLEN], s2_name[STRLEN], *sname ;
int ac, nargs, i, n, options, max_index ;
int msec, minutes, seconds, nsubjects, input ;
struct timeb start ;
MRI *mri_seg, *mri_tmp, *mri_in ;
TRANSFORM *transform ;
// int counts ;
int t;
RANDOM_FOREST *rf = NULL ;
GCA *gca = NULL ;
Progname = argv[0] ;
ErrorInit(NULL, NULL, NULL) ;
DiagInit(NULL, NULL, NULL) ;
TimerStart(&start) ;
parms.width = parms.height = parms.depth = DEFAULT_VOLUME_SIZE ;
parms.ntrees = 10 ;
parms.max_depth = 10 ;
parms.wsize = 1 ;
parms.training_size = 100 ;
parms.training_fraction = .5 ;
parms.feature_fraction = 1 ;
/* rkt: check for and handle version tag */
nargs = handle_version_option
(argc, argv,
"$Id: mri_rf_long_train.c,v 1.5 2012/06/15 12:22:28 fischl Exp $",
"$Name: $");
if (nargs && argc - nargs == 1)
exit (0);
argc -= nargs;
// parse command line args
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)) /* hasn't been set on command line */
{
cp = getenv("SUBJECTS_DIR") ;
if (!cp)
ErrorExit(ERROR_BADPARM, "%s: SUBJECTS_DIR not defined in environment",
Progname);
strcpy(subjects_dir, cp) ;
}
if (argc < 3)
usage_exit(1) ;
// options parsed. subjects, tp1 and tp2 and rf name remaining
out_fname = argv[argc-1] ;
nsubjects = (argc-2)/3 ;
for (options = i = 0 ; i < nsubjects ; i++)
{
if (argv[i+1][0] == '-')
{
nsubjects-- ;
options++ ;
}
}
printf("training on %d subject and writing results to %s\n",
nsubjects, out_fname) ;
// rf_inputs can be T1, PD, ...per subject
if (parms.nvols == 0)
parms.nvols = ninputs ;
/* gca reads same # of inputs as we read
from command line - not the case if we are mapping to flash */
n = 0 ;
//////////////////////////////////////////////////////////////////
// set up gca direction cosines, width, height, depth defaults
gca = GCAread(gca_name) ;
if (gca == NULL)
ErrorExit(ERROR_NOFILE, "%s: could not read GCA from %s", Progname, gca_name) ;
/////////////////////////////////////////////////////////////////////////
// weird way options and subject name are mixed here
/////////////////////////////////////////////////////////
// first calculate mean
////////////////////////////////////////////////////////
// going through the subject one at a time
max_index = nsubjects+options ;
nargs = 0 ;
mri_in = NULL ;
#ifdef HAVE_OPENMP
subject_name = NULL ; sname = NULL ; t = 0 ;
// counts = 0 ; would be private
input = 0 ;
transform = NULL ;
tp1_name = tp2_name = NULL ;
mri_tmp = mri_seg = NULL ;
#pragma omp parallel for firstprivate(tp1_name, tp2_name, mri_in,mri_tmp, input, xform_name, transform, subjects_dir, force_inputs, conform, Progname, mri_seg, subject_name, s1_name, s2_name, sname, t, fname) shared(mri_inputs, transforms, mri_segs,argv) schedule(static,1)
#endif
for (i = 0 ; i < max_index ; i++)
{
subject_name = argv[3*i+1] ;
tp1_name = argv[3*i+2] ;
tp2_name = argv[3*i+3] ;
sprintf(s1_name, "%s_%s.long.%s_base", subject_name, tp1_name, subject_name) ;
sprintf(s2_name, "%s_%s.long.%s_base", subject_name, tp2_name, subject_name) ;
//////////////////////////////////////////////////////////////
printf("***************************************"
"************************************\n");
printf("processing subject %s, %d of %d (%s and %s)...\n", subject_name,i+1-nargs,
nsubjects, s1_name,s2_name);
for (t = 0 ; t < 2 ; t++)
{
sname = t == 0 ? s1_name : s2_name;
// reading this subject segmentation
sprintf(fname, "%s/%s/mri/%s", subjects_dir, sname, seg_dir) ;
if (Gdiag & DIAG_SHOW && DIAG_VERBOSE_ON)
fprintf(stderr, "Reading segmentation from %s...\n", fname) ;
mri_seg = MRIread(fname) ;
if (!mri_seg)
ErrorExit(ERROR_NOFILE, "%s: could not read segmentation file %s",
Progname, fname) ;
if ((mri_seg->type != MRI_UCHAR) && (make_uchar != 0))
{
MRI *mri_tmp ;
mri_tmp = MRIchangeType(mri_seg, MRI_UCHAR, 0, 1,1);
MRIfree(&mri_seg) ;
mri_seg = mri_tmp ;
}
if (wmsa_fname)
{
MRI *mri_wmsa ;
sprintf(fname, "%s/%s/mri/%s", subjects_dir, sname, wmsa_fname) ;
printf("reading WMSA labels from %s...\n", fname) ;
mri_wmsa = MRIread(fname) ;
if (mri_wmsa == NULL)
ErrorExit(ERROR_NOFILE, "%s: could not read WMSA file %s", fname) ;
MRIbinarize(mri_wmsa, mri_wmsa, 1, 0, WM_hypointensities) ;
MRIcopyLabel(mri_wmsa, mri_seg, WM_hypointensities) ;
lateralize_hypointensities(mri_seg) ;
if (Gdiag & DIAG_WRITE && DIAG_VERBOSE_ON )
{
char s[STRLEN] ;
sprintf(s, "%s/%s/mri/seg_%s",
subjects_dir, subject_name, wmsa_fname) ;
MRIwrite(mri_seg, s) ;
}
}
if (binarize)
{
int j ;
for (j = 0 ; j < 256 ; j++)
{
if (j == binarize_in)
MRIreplaceValues(mri_seg, mri_seg, j, binarize_out) ;
else
MRIreplaceValues(mri_seg, mri_seg, j, 0) ;
}
}
if (insert_fname)
{
MRI *mri_insert ;
sprintf(fname, "%s/%s/mri/%s",
subjects_dir, subject_name, insert_fname) ;
mri_insert = MRIread(fname) ;
if (mri_insert == NULL)
ErrorExit(ERROR_NOFILE,
"%s: could not read volume from %s for insertion",
Progname, insert_fname) ;
MRIbinarize(mri_insert, mri_insert, 1, 0, insert_label) ;
MRIcopyLabel(mri_insert, mri_seg, insert_label) ;
MRIfree(&mri_insert) ;
}
replaceLabels(mri_seg) ;
MRIeraseBorderPlanes(mri_seg, 1) ;
////////////////////////////////////////////////////////////
if (DIAG_VERBOSE_ON)
fprintf(stderr,
"Gather all input volumes for the subject %s.\n",
subject_name);
// inputs must be coregistered
// note that inputs are T1, PD, ... per subject (same TE, TR, FA)
for (input = 0 ; input < ninputs ; input++)
{
//////////// set the gca type //////////////////////////////
// is this T1/PD training?
// how can we allow flash data training ???????
// currently checks the TE, TR, FA to be the same for all inputs
// thus we cannot allow flash data training.
////////////////////////////////////////////////////////////
sprintf(fname, "%s/%s/mri/%s", subjects_dir, sname,input_names[input]);
if (DIAG_VERBOSE_ON)
printf("reading co-registered input from %s...\n", fname) ;
fprintf(stderr, " reading input %d: %s\n", input, fname);
mri_tmp = MRIread(fname) ;
if (!mri_tmp)
ErrorExit
(ERROR_NOFILE,
"%s: could not read image from file %s", Progname, fname) ;
// input check 1
if (getSliceDirection(mri_tmp) != MRI_CORONAL)
{
ErrorExit
(ERROR_BADPARM,
"%s: must be in coronal direction, but it is not\n",
fname);
}
// input check 2
if (conform &&
(mri_tmp->xsize != 1 || mri_tmp->ysize != 1 || mri_tmp->zsize != 1))
{
ErrorExit
(ERROR_BADPARM,
"%s: must have 1mm voxel size, but have (%f, %f, %f)\n",
fname, mri_tmp->xsize, mri_tmp->ysize, mri_tmp->ysize);
}
// input check 3 is removed. now we can handle c_(ras) != 0 case
// input check 4
if (i == 0)
{
TRs[input] = mri_tmp->tr ;
FAs[input] = mri_tmp->flip_angle ;
TEs[input] = mri_tmp->te ;
}
else if ((force_inputs == 0) &&
(!FEQUAL(TRs[input],mri_tmp->tr) ||
!FEQUAL(FAs[input],mri_tmp->flip_angle) ||
!FEQUAL(TEs[input], mri_tmp->te)))
ErrorExit
(ERROR_BADPARM,
"%s: subject %s input volume %s: sequence parameters "
"(%2.1f, %2.1f, %2.1f)"
"don't match other inputs (%2.1f, %2.1f, %2.1f)",
Progname, subject_name, fname,
mri_tmp->tr, DEGREES(mri_tmp->flip_angle), mri_tmp->te,
TRs[input], DEGREES(FAs[input]), TEs[input]) ;
// first time do the following
if (input == 0)
{
int nframes = ninputs ;
///////////////////////////////////////////////////////////
mri_in = MRIallocSequence(mri_tmp->width, mri_tmp->height, mri_tmp->depth,
mri_tmp->type, nframes) ;
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,nframes) ;
MRIcopyHeader(mri_tmp, mri_in) ;
}
// -mask option ////////////////////////////////////////////
if (mask_fname)
{
MRI *mri_mask ;
sprintf(fname, "%s/%s/mri/%s",
subjects_dir, subject_name, mask_fname);
printf("reading volume %s for masking...\n", fname) ;
mri_mask = MRIread(fname) ;
if (!mri_mask)
ErrorExit(ERROR_NOFILE, "%s: could not open mask volume %s.\n",
Progname, fname) ;
MRImask(mri_tmp, mri_mask, mri_tmp, 0, 0) ;
MRIfree(&mri_mask) ;
}
MRIcopyFrame(mri_tmp, mri_in, 0, input) ;
MRIfree(&mri_tmp) ;
}// end of inputs per subject
/////////////////////////////////////////////////////////
// xform_name is given, then we can use the consistent c_(r,a,s) for gca
/////////////////////////////////////////////////////////
if (xform_name)
{
// we read talairach.xfm which is a RAS-to-RAS
sprintf(fname, "%s/%s/mri/transforms/%s", subjects_dir, sname, xform_name) ;
if (Gdiag & DIAG_SHOW && DIAG_VERBOSE_ON)
printf("INFO: reading transform file %s...\n", fname);
if (!FileExists(fname))
{
fprintf(stderr,"ERROR: cannot find transform file %s\n",fname);
exit(1);
}
transform = TransformRead(fname);
if (!transform)
ErrorExit(ERROR_NOFILE, "%s: could not read transform from file %s",
Progname, fname);
// modify_transform(transform, mri_in, gca);
// Here we do 2 things
// 1. modify gca direction cosines to
// that of the transform destination (both linear and non-linear)
// 2. if ras-to-ras transform,
// then change it to vox-to-vox transform (linear case)
// modify transform to store inverse also
TransformInvert(transform, mri_in) ;
}
else
{
// GCAreinit(mri_in, gca);
// just use the input value, since dst = src volume
transform = TransformAlloc(LINEAR_VOXEL_TO_VOXEL, NULL) ;
}
/////////////////////////////////////////////////////////
if (do_sanity_check)
{
// conduct a sanity check of particular labels, most importantly
// hippocampus, that such labels do not exist in talairach coords
// where they are known not to belong (indicating a bad manual edit)
int errs = check(mri_seg, subjects_dir, subject_name);
if (errs)
{
printf(
"ERROR: mri_ca_train: possible bad training data! subject:\n"
"\t%s/%s\n\n", subjects_dir, subject_name);
fflush(stdout) ;
sanity_check_badsubj_count++;
}
}
mri_segs[i][t] = mri_seg ;
mri_inputs[i][t] = mri_in ;
transforms[i][t] = transform ;
}
}
rf = train_rforest(mri_inputs, mri_segs, transforms, nsubjects, gca, &parms, wm_thresh,wmsa_whalf, 2) ;
printf("writing random forest to %s\n", out_fname) ;
if (RFwrite(rf, out_fname) != NO_ERROR)
ErrorExit
(ERROR_BADFILE, "%s: could not write rf to %s", Progname, out_fname) ;
msec = TimerStop(&start) ;
seconds = nint((float)msec/1000.0f) ;
minutes = seconds / 60 ;
seconds = seconds % 60 ;
printf("classifier array training took %d minutes and %d seconds.\n", minutes, seconds) ;
exit(0) ;
return(0) ;
}
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) ;
}
