int main(int argc, char *argv[]) {
int nargs;
/* rkt: check for and handle version tag */
nargs = handle_version_option (argc, argv, "$Id: mri_head.c,v 1.7 2011/03/02 00:04:16 nicks Exp $", "$Name: stable5 $");
if (nargs && argc - nargs == 1)
exit (0);
argc -= nargs;
prog_name = argv[0];
short_prog_name = strrchr(prog_name, '/');
short_prog_name = (short_prog_name == NULL ? prog_name : short_prog_name + 1);
Progname = short_prog_name;
get_options(argc, argv);
if (action == ACTION_USAGE)
usage(0);
else if (action == ACTION_IDENTIFY)
dummy_identify();
else if (action == ACTION_READ)
dummy_read();
else
usage(1);
exit(0);
} /* end main() */
int main(int argc, char *argv[]) {
int i;
int nargs;
/* rkt: check for and handle version tag */
nargs = handle_version_option
(argc, argv,
"$Id: repair_siemens_file.c,v 1.11 2011/03/02 00:04:35 nicks Exp $",
"$Name: stable5 $");
if (nargs && argc - nargs == 1)
exit (0);
argc -= nargs;
/* ----- get the basename of the executable ----- */
Progname = strrchr(argv[0], '/');
Progname = (Progname == NULL ? argv[0] : Progname + 1);
if (argc < 2) {
usage();
}
for (i = 1;i < argc;i++) {
repair_file(argv[i]);
}
exit(0);
} /* end main() */
int main ( int argc, char** argv ) {
int nargs;
char *env;
/* rkt: check for and handle version tag */
nargs = handle_version_option
(argc, argv,
"$Id: test_window_env.c,v 1.10 2011/03/02 00:04:40 nicks Exp $",
"$Name: $");
if (nargs && argc - nargs == 1)
exit (0);
argc -= nargs;
env = getenv("DISPLAY");
if ( NULL == env ) {
printf("DISPLAY env var not set. Skipping test.\n");
exit (77);
}
#if 0
GLenum bSuccess;
bSuccess = tkoInitWindow( "test" );
printf( "tkoInitWindow() returned %s\n",
(GL_TRUE == bSuccess ? "GL_TRUE" : "GL_FALSE") );
#endif
InitDisplay();
FindVisual();
return 0;
}
/*---------------------------------------------------------------*/
int main(int argc, char *argv[]) {
int nargs;
nargs = handle_version_option (argc, argv, vcid, "$Name: stable5 $");
if (nargs && argc - nargs == 1) exit (0);
argc -= nargs;
cmdline = argv2cmdline(argc,argv);
uname(&uts);
getcwd(cwd,2000);
Progname = argv[0] ;
argc --;
argv++;
ErrorInit(NULL, NULL, NULL) ;
DiagInit(NULL, NULL, NULL) ;
if (argc == 0) usage_exit();
parse_commandline(argc, argv);
check_options();
if (checkoptsonly) return(0);
dump_options(stdout);
SUBJECTS_DIR = getenv("SUBJECTS_DIR");
if (SUBJECTS_DIR == NULL) {
printf("ERROR: SUBJECTS_DIR not defined in environment\n");
exit(1);
}
return 0;
}
int
main(int argc, char *argv[]) {
char **av, *in_fname, *out_fname ;
int ac, nargs ;
MRI_SURFACE *mris ;
float alpha, beta, gamma ;
/* rkt: check for and handle version tag */
nargs = handle_version_option (argc, argv, "$Id: mris_rotate.c,v 1.6 2011/03/02 00:04:33 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() ;
in_fname = argv[1] ;
if (sscanf(argv[2], "%f", &alpha) != 1)
ErrorExit(ERROR_BADPARM, "%s: could not scan alpha from %s",
Progname, argv[2]) ;
if (sscanf(argv[3], "%f", &beta) != 1)
ErrorExit(ERROR_BADPARM, "%s: could not scan beta from %s",
Progname, argv[3]) ;
if (sscanf(argv[4], "%f", &gamma) != 1)
ErrorExit(ERROR_BADPARM, "%s: could not scan gamma from %s",
Progname, argv[4]) ;
out_fname = argv[5] ;
mris = MRISfastRead(in_fname) ;
if (!mris)
ErrorExit(ERROR_NOFILE, "%s: could not read surface file %s",
Progname, in_fname) ;
alpha = RADIANS(alpha) ;
beta = RADIANS(beta) ;
gamma = RADIANS(gamma) ;
MRIScenter(mris, mris) ;
MRISrotate(mris, mris, alpha, beta, gamma) ;
if (!mris)
ErrorExit(ERROR_NOFILE, "%s: could not rotate surface", Progname) ;
if (Gdiag & DIAG_SHOW)
fprintf(stderr, "writing rotated surface to %s\n", out_fname) ;
MRISwrite(mris, out_fname) ;
exit(0) ;
return(0) ; /* for ansi */
}
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 */
}
int
main(int argc, char *argv[]) {
char **av ;
int ac, nargs ;
MRI *mri_src, *mri_dst = NULL ;
char *in_fname, *out_fname ;
/* rkt: check for and handle version tag */
nargs = handle_version_option (argc, argv, "$Id: mri_polv.c,v 1.6 2011/03/02 00:04:24 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 < 1)
argc = 1 ;
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)
fprintf(stderr, "reading from %s...", in_fname) ;
mri_src = MRIread(in_fname) ;
if (!mri_src)
ErrorExit(ERROR_NO_FILE, "%s: could not open source file %s",
Progname, in_fname) ;
if (verbose)
fprintf(stderr, "done.\ncalculating plane of least variance...") ;
mri_dst = MRIcentralPlaneOfLeastVarianceNormal(mri_src, NULL, window_size) ;
if (!mri_dst)
ErrorExit(ERROR_BADPARM, "%s: plane of least variance calculation failed",
Progname) ;
if (verbose)
fprintf(stderr, "\ndone. writing output to %s", out_fname) ;
MRIwrite(mri_dst, out_fname) ;
if (verbose)
fprintf(stderr, "\n") ;
exit(0) ;
return(0) ;
}
int
main(int argc, char *argv[]) {
char **av ;
int ac, nargs ;
MRI *mri_src, *mri_dst ;
char *in_fname, *out_fname ;
int label, nvox ;
/* rkt: check for and handle version tag */
nargs = handle_version_option (argc, argv, "$Id: mri_copy_values.c,v 1.5 2011/03/02 00:04:14 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 < 2)
ErrorExit(ERROR_BADPARM, "%s: no input name specified", Progname) ;
in_fname = argv[1] ;
if (argc < 3)
ErrorExit(ERROR_BADPARM, "%s: no value specified", Progname) ;
label = atoi(argv[2]) ;
if (argc < 4)
ErrorExit(ERROR_BADPARM, "%s: no output name specified", Progname) ;
out_fname = argv[3] ;
fprintf(stderr, "reading from %s...\n", in_fname) ;
mri_src = MRIread(in_fname) ;
if (!mri_src)
ErrorExit(ERROR_NOFILE, "%s: could not read input volume %s",
Progname, in_fname) ;
mri_dst = MRIread(out_fname) ;
if (!mri_dst)
ErrorExit(ERROR_NOFILE, "%s: could not read destination volume %s",
Progname, out_fname) ;
nvox = MRIcopyLabel(mri_src, mri_dst, label) ;
fprintf(stderr, "%d voxels copied from input to output volume...\n", nvox);
fprintf(stderr, "writing to %s...\n", out_fname) ;
MRIwrite(mri_dst, out_fname) ;
MRIfree(&mri_dst) ;
MRIfree(&mri_src) ;
exit(0) ;
return(0) ;
}
int
main(int argc, char *argv[]) {
char **av ;
int ac, nargs, i ;
MRI *mri_src, *mri_dst = NULL ;
char *in_fname, *out_fname ;
/* rkt: check for and handle version tag */
nargs = handle_version_option (argc, argv, "$Id: mri_reduce.c,v 1.7 2011/03/02 00:04:24 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 < 1)
argc = 1 ;
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] ;
fprintf(stderr, "reading from %s...", in_fname) ;
mri_src = MRIread(in_fname) ;
i = 0 ;
do {
if (i)
mri_src = MRIcopy(mri_dst, NULL) ;
fprintf(stderr, "\nreducing by 2");
mri_dst = MRIallocSequence(mri_src->width/2, mri_src->height/2, mri_src->depth/2, MRI_FLOAT, mri_src->nframes);
MRIreduce(mri_src, mri_dst) ;
MRIfree(&mri_src) ;
} while (++i < reductions) ;
fprintf(stderr, "\nwriting to %s", out_fname) ;
MRIwrite(mri_dst, out_fname) ;
fprintf(stderr, "\n") ;
exit(0) ;
return(0) ;
}
int
main(int argc, char *argv[]) {
char **av ;
int ac, nargs ;
MRI *mri_src, *mri_ref, *mri_tmp ;
double accuracy ;
MRI_REGION box ;
/* rkt: check for and handle version tag */
nargs = handle_version_option (argc, argv, "$Id: mri_label_accuracy.c,v 1.2 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 < 3)
usage_exit(1) ;
mri_src = MRIread(argv[1]) ;
if (mri_src == NULL)
ErrorExit(ERROR_BADPARM, "%s: could not read input volume %s\n", Progname,argv[1]);
MRIboundingBox(mri_src, 0, &box) ;
mri_tmp = MRIextractRegionAndPad(mri_src, NULL, &box, PAD) ;
MRIfree(&mri_src) ; mri_src = mri_tmp ;
if (mri_src->type == MRI_SHORT)
{
mri_tmp = MRIchangeType(mri_src, MRI_FLOAT, 0, 0, 0) ;
MRIfree(&mri_src) ; mri_src = mri_tmp ;
}
mri_ref = MRIread(argv[2]) ;
if (mri_ref == NULL)
ErrorExit(ERROR_BADPARM, "%s: could not read reference volume %s\n", Progname,argv[1]);
MRIboundingBox(mri_ref, 0, &box) ;
mri_tmp = MRIextractRegionAndPad(mri_ref, NULL, &box, PAD) ;
MRIfree(&mri_ref) ; mri_ref = mri_tmp ;
accuracy = MRIcomputeLabelAccuracy(mri_src, mri_ref, MRI_MEAN_MIN_DISTANCE, stdout) ;
if (Gdiag_fp)
fclose(Gdiag_fp) ;
exit(0) ;
return(0) ;
}
int
main(int argc, char *argv[]) {
char **av ;
int ac, nargs, nsize ;
MRI_SURFACE *mris ;
MRI *mri ;
nargs = handle_version_option (argc, argv, "$Id: mris_nudge.c,v 1.2 2011/03/02 00:04:31 nicks Exp $", "$Name: stable5 $");
if (nargs && argc - nargs == 1)
exit (0);
argc -= nargs;
Gx = Gy = Gz = -1 ;
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(1) ;
mris = MRISread(argv[1]) ;
if (mris == NULL)
ErrorExit(ERROR_NOFILE, "%s: could not read surface from %s", Progname, argv[1]) ;
MRIScomputeMetricProperties(mris) ;
MRISstoreMetricProperties(mris) ;
mri = MRIread(argv[2]) ;
if (mri == NULL)
ErrorExit(ERROR_NOFILE, "%s: could not read volume from %s", Progname, argv[2]) ;
target_vnos[nvertices] = atoi(argv[3]) ;
target_vals[nvertices] = atof(argv[4]) ;
nsize = atoi(argv[5]) ;
printf("nudging %d vertex region around vertex %d to target val %2.1f\n",
nsize, target_vnos[nvertices], target_vals[nvertices]) ;
nvertices++ ;
MRISerodeRipped(mris, nsize) ;
MRISrepositionSurface(mris, mri, target_vnos, target_vals, nvertices, nsize, sigma) ;
MRISunrip(mris) ;
printf("writing repositioned surface to %s\n", argv[6]) ;
MRISwrite(mris, argv[6]) ;
return(0) ;
}
/***-------------------------------------------------------****/
int main(int argc, char *argv[])
{
int nargs, index, ac, nvolumes;
char **av ;
MRI *mri_and = NULL, *mri ;
/* rkt: check for and handle version tag */
nargs = handle_version_option (argc, argv, vcid, "$Name: $");
if (nargs && argc - nargs == 1)
exit (0);
Progname = argv[0] ;
argc -= nargs;
ac = argc ;
av = argv ;
for ( ; argc > 1 && ISOPTION(*argv[1]) ; argc--, argv++)
{
nargs = get_option(argc, argv) ;
argc -= nargs ;
argv += nargs ;
}
nvolumes = argc-2 ;
if (nvolumes <= 0)
usage_exit() ;
printf("processing %d input files\n", nvolumes) ;
ErrorInit(NULL, NULL, NULL) ;
DiagInit(NULL, NULL, NULL) ;
for (index = 0 ; index < nvolumes ; index++)
{
char *fname = argv[index+1] ;
printf("processing input volume %d of %d: %s\n",
index+1, nvolumes, fname) ;
mri = MRIread(fname) ;
if (index == 0)
mri_and = MRIcopy(mri, NULL) ;
else
MRIand(mri, mri_and, mri_and, 0) ;
MRIfree(&mri) ;
}
printf("writing output to %s\n", argv[argc-1]) ;
MRIwrite(mri_and, argv[argc-1]) ;
exit(0);
} /* end main() */
int
main(int argc, char *argv[])
{
MRI_SURFACE *mris ;
char **av, *in_fname, *out_fname ;
int ac, nargs ;
MRI *mri_distance ;
/* rkt: check for and handle version tag */
nargs = handle_version_option
(argc, argv,
"$Id: mris_distance_map.c,v 1.2 2011/03/02 00:04:31 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 < 3) usage_exit() ;
in_fname = argv[1] ;
out_fname = argv[2] ;
mris = MRISread(in_fname) ;
if (mris == NULL)
ErrorExit(ERROR_NOFILE, "%s: could not load surface %s", Progname, out_fname) ;
mri_distance = MRIScomputeDistanceMap(mris, NULL, ref_vertex_no) ;
MRIwrite(mri_distance, out_fname) ;
MRISfree(&mris) ;
exit(0) ;
return(0) ; /* for ansi */
}
/*---------------------------------------------------------------*/
int main(int argc, char *argv[]) {
int nargs;
char *surf1_fname ;
char *surf2_fname ;
char *out_fname ;
MRI_SURFACE *mris1, *mris2 ;
nargs = handle_version_option (argc, argv, vcid, "$Name: $");
if (nargs && argc - nargs == 1) exit (0);
argc -= nargs;
cmdline = argv2cmdline(argc,argv);
uname(&uts);
getcwd(cwd,2000);
Progname = argv[0] ;
argc --;
argv++;
ErrorInit(NULL, NULL, NULL) ;
DiagInit(NULL, NULL, NULL) ;
if (argc == 0) usage_exit();
parse_commandline(argc, argv);
check_options();
if (checkoptsonly) return(0);
dump_options(stdout);
SUBJECTS_DIR = getenv("SUBJECTS_DIR");
if (SUBJECTS_DIR == NULL) {
printf("ERROR: SUBJECTS_DIR not defined in environment\n");
exit(1);
}
surf1_fname = argv[0] ; surf2_fname = argv[1] ; out_fname = argv[2] ;
mris1 = MRISread(surf1_fname) ;
if (mris1 == NULL)
ErrorExit(ERROR_NOFILE, "could not read surface 1 from %s", surf1_fname) ;
mris2 = MRISread(surf2_fname) ;
if (mris2 == NULL)
ErrorExit(ERROR_NOFILE, "could not read surface 2 from %s", surf2_fname) ;
compute_surface_distance(mris1, mris2, mris1) ;
MRISwriteValues(mris1, out_fname) ;
return 0;
}
int
main(int argc, char *argv[]) {
char **av, *in_fname, *out_fname ;
int ac, nargs ;
MRI_SURFACE *mris ;
float radius, scale ;
/* rkt: check for and handle version tag */
nargs = handle_version_option (argc, argv, "$Id: mris_rescale.c,v 1.5 2011/03/02 00:04:33 nicks Exp $", "$Name: $");
if (nargs && argc - nargs == 1)
exit (0);
argc -= nargs;
Progname = argv[0] ;
ErrorInit(NULL, NULL, NULL) ;
DiagInit(NULL, NULL, NULL) ;
ac = argc ;
av = argv ;
for ( ; argc > 1 && ISOPTION(*argv[1]) ; argc--, argv++) {
nargs = get_option(argc, argv) ;
argc -= nargs ;
argv += nargs ;
}
if (argc < 3)
usage_exit() ;
in_fname = argv[1] ;
out_fname = argv[2] ;
mris = MRISread(in_fname) ;
if (!mris)
ErrorExit(ERROR_NOFILE, "%s: could not read surface file %s",
Progname, in_fname) ;
radius = MRISaverageRadius(mris) ;
scale = DEFAULT_RADIUS / radius ;
MRISscaleBrain(mris, mris, scale) ;
MRISwrite(mris, out_fname) ;
exit(0) ;
return(0) ; /* for ansi */
}
int
main(int argc, char *argv[]) {
char **av, *out_fname, *in_fname ;
int ac, nargs ;
MRI_SURFACE *mris ;
MRI *mri_interior, *mri_template = NULL, *mri_buffer = NULL;
char cmdline[CMD_LINE_LEN] ;
make_cmd_version_string
(argc, argv,
"$Id: mris_fill.c,v 1.6 2011/03/02 00:04:32 nicks Exp $", "$Name: $",
cmdline);
/* rkt: check for and handle version tag */
nargs = handle_version_option (argc, argv, "$Id: mris_fill.c,v 1.6 2011/03/02 00:04:32 nicks Exp $", "$Name: $");
if (nargs && argc - nargs == 1)
exit (0);
argc -= nargs;
Progname = argv[0] ;
ErrorInit(NULL, NULL, NULL) ;
DiagInit(NULL, NULL, NULL) ;
ac = argc ;
av = argv ;
for ( ; argc > 1 && ISOPTION(*argv[1]) ; argc--, argv++) {
nargs = get_option(argc, argv) ;
argc -= nargs ;
argv += nargs ;
}
if (argc != 3)
usage_exit() ;
in_fname = argv[1] ;
out_fname = argv[2] ;
fprintf(stderr, "reading surface from %s...\n", in_fname) ;
mris = MRISread(in_fname) ;
if (template)
int
main(int argc, char *argv[]) {
char **av, fname[STRLEN] ;
int ac, nargs, i ;
char *in_fname, *out_fname ;
int msec, minutes, seconds ;
struct timeb start ;
/* rkt: check for and handle version tag */
nargs = handle_version_option (argc, argv, "$Id: main_template.c,v 1.5 2011/03/02 00:04:40 nicks Exp $", "$Name: $");
if (nargs && argc - nargs == 1)
exit (0);
argc -= nargs;
Progname = argv[0] ;
ErrorInit(NULL, NULL, NULL) ;
DiagInit(NULL, NULL, NULL) ;
TimerStart(&start) ;
ac = argc ;
av = argv ;
for ( ; argc > 1 && ISOPTION(*argv[1]) ; argc--, argv++) {
nargs = get_option(argc, argv) ;
argc -= nargs ;
argv += nargs ;
}
if (argc < 3)
usage_exit(1) ;
msec = TimerStop(&start) ;
seconds = nint((float)msec/1000.0f) ;
minutes = seconds / 60 ;
seconds = seconds % 60 ;
fprintf(stderr, "inverse operator application took %d minutes"
" and %d seconds.\n", minutes, seconds) ;
exit(0) ;
return(0) ;
}
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)
{
int nargs, err, asegid, c, r, s, nctx, annot,vtxno,nripped;
int annotid, IsCortex=0, IsWM=0, IsHypo=0, hemi=0, segval=0;
int RibbonVal=0,nbrute=0;
float dmin=0.0, lhRibbonVal=0, rhRibbonVal=0;
/* rkt: check for and handle version tag */
nargs = handle_version_option (argc, argv, vcid, "$Name: stable5 $");
if (nargs && argc - nargs == 1)
{
exit (0);
}
argc -= nargs;
Progname = argv[0] ;
argc --;
argv++;
ErrorInit(NULL, NULL, NULL) ;
DiagInit(NULL, NULL, NULL) ;
if (argc == 0)
{
usage_exit();
}
SUBJECTS_DIR = getenv("SUBJECTS_DIR");
if (SUBJECTS_DIR==NULL)
{
printf("ERROR: SUBJECTS_DIR not defined in environment\n");
exit(1);
}
parse_commandline(argc, argv);
check_options();
dump_options(stdout);
/* ------ Load subject's lh white surface ------ */
sprintf(tmpstr,"%s/%s/surf/lh.white",SUBJECTS_DIR,subject);
printf("\nReading lh white surface \n %s\n",tmpstr);
lhwhite = MRISread(tmpstr);
if (lhwhite == NULL)
{
fprintf(stderr,"ERROR: could not read %s\n",tmpstr);
exit(1);
}
/* ------ Load subject's lh pial surface ------ */
sprintf(tmpstr,"%s/%s/surf/lh.pial",SUBJECTS_DIR,subject);
printf("\nReading lh pial surface \n %s\n",tmpstr);
lhpial = MRISread(tmpstr);
if (lhpial == NULL)
{
fprintf(stderr,"ERROR: could not read %s\n",tmpstr);
exit(1);
}
if (lhwhite->nvertices != lhpial->nvertices)
{
printf("ERROR: lh white and pial have a different number of "
"vertices (%d,%d)\n",
lhwhite->nvertices,lhpial->nvertices);
exit(1);
}
/* ------ Load lh annotation ------ */
sprintf(annotfile,"%s/%s/label/lh.%s.annot",SUBJECTS_DIR,subject,annotname);
printf("\nLoading lh annotations from %s\n",annotfile);
err = MRISreadAnnotation(lhwhite, annotfile);
if (err)
{
printf("ERROR: MRISreadAnnotation() failed %s\n",annotfile);
exit(1);
}
/* ------ Load subject's rh white surface ------ */
sprintf(tmpstr,"%s/%s/surf/rh.white",SUBJECTS_DIR,subject);
printf("\nReading rh white surface \n %s\n",tmpstr);
rhwhite = MRISread(tmpstr);
if (rhwhite == NULL)
{
fprintf(stderr,"ERROR: could not read %s\n",tmpstr);
exit(1);
}
/* ------ Load subject's rh pial surface ------ */
sprintf(tmpstr,"%s/%s/surf/rh.pial",SUBJECTS_DIR,subject);
printf("\nReading rh pial surface \n %s\n",tmpstr);
rhpial = MRISread(tmpstr);
if (rhpial == NULL)
{
fprintf(stderr,"ERROR: could not read %s\n",tmpstr);
exit(1);
}
if (rhwhite->nvertices != rhpial->nvertices)
{
printf("ERROR: rh white and pial have a different "
"number of vertices (%d,%d)\n",
rhwhite->nvertices,rhpial->nvertices);
exit(1);
}
/* ------ Load rh annotation ------ */
sprintf(annotfile,"%s/%s/label/rh.%s.annot",SUBJECTS_DIR,subject,annotname);
printf("\nLoading rh annotations from %s\n",annotfile);
err = MRISreadAnnotation(rhwhite, annotfile);
if (err)
{
printf("ERROR: MRISreadAnnotation() failed %s\n",annotfile);
exit(1);
}
if (lhwhite->ct)
{
printf("Have color table for lh white annotation\n");
}
if (rhwhite->ct)
{
printf("Have color table for rh white annotation\n");
}
//print_annotation_table(stdout);
if (UseRibbon)
{
sprintf(tmpstr,"%s/%s/mri/lh.ribbon.mgz",SUBJECTS_DIR,subject);
printf("Loading lh ribbon mask from %s\n",tmpstr);
lhRibbon = MRIread(tmpstr);
if (lhRibbon == NULL)
{
printf("ERROR: loading %s\n",tmpstr);
exit(1);
}
sprintf(tmpstr,"%s/%s/mri/rh.ribbon.mgz",SUBJECTS_DIR,subject);
printf("Loading rh ribbon mask from %s\n",tmpstr);
rhRibbon = MRIread(tmpstr);
if (rhRibbon == NULL)
{
printf("ERROR: loading %s\n",tmpstr);
exit(1);
}
}
if (UseNewRibbon)
{
sprintf(tmpstr,"%s/%s/mri/ribbon.mgz",SUBJECTS_DIR,subject);
printf("Loading ribbon segmentation from %s\n",tmpstr);
RibbonSeg = MRIread(tmpstr);
if (RibbonSeg == NULL)
{
printf("ERROR: loading %s\n",tmpstr);
exit(1);
}
}
if (LabelHypoAsWM)
{
sprintf(tmpstr,"%s/%s/mri/filled.mgz",SUBJECTS_DIR,subject);
printf("Loading filled from %s\n",tmpstr);
filled = MRIread(tmpstr);
if (filled == NULL)
{
printf("ERROR: loading filled %s\n",tmpstr);
exit(1);
}
}
// ------------ Rip -----------------------
if (RipUnknown)
{
printf("Ripping vertices labeled as unkown\n");
nripped = 0;
for (vtxno = 0; vtxno < lhwhite->nvertices; vtxno++)
{
annot = lhwhite->vertices[vtxno].annotation;
CTABfindAnnotation(lhwhite->ct, annot, &annotid);
// Sometimes the annotation will be "none" indicated by
// annotid = -1. We interpret this as "unknown".
if (annotid == 0 || annotid == -1)
{
lhwhite->vertices[vtxno].ripflag = 1;
lhpial->vertices[vtxno].ripflag = 1;
nripped++;
}
}
printf("Ripped %d vertices from left hemi\n",nripped);
nripped = 0;
for (vtxno = 0; vtxno < rhwhite->nvertices; vtxno++)
{
annot = rhwhite->vertices[vtxno].annotation;
CTABfindAnnotation(rhwhite->ct, annot, &annotid);
if (annotid == 0 || annotid == -1)
{
rhwhite->vertices[vtxno].ripflag = 1;
rhpial->vertices[vtxno].ripflag = 1;
nripped++;
}
}
printf("Ripped %d vertices from right hemi\n",nripped);
}
printf("\n");
printf("Building hash of lh white\n");
lhwhite_hash = MHTfillVertexTableRes(lhwhite, NULL,CURRENT_VERTICES,hashres);
printf("\n");
printf("Building hash of lh pial\n");
lhpial_hash = MHTfillVertexTableRes(lhpial, NULL,CURRENT_VERTICES,hashres);
printf("\n");
printf("Building hash of rh white\n");
rhwhite_hash = MHTfillVertexTableRes(rhwhite, NULL,CURRENT_VERTICES,hashres);
printf("\n");
printf("Building hash of rh pial\n");
rhpial_hash = MHTfillVertexTableRes(rhpial, NULL,CURRENT_VERTICES,hashres);
/* ------ Load ASeg ------ */
sprintf(tmpstr,"%s/%s/mri/aseg.mgz",SUBJECTS_DIR,subject);
if (!fio_FileExistsReadable(tmpstr))
{
sprintf(tmpstr,"%s/%s/mri/aseg.mgh",SUBJECTS_DIR,subject);
if (!fio_FileExistsReadable(tmpstr))
{
sprintf(tmpstr,"%s/%s/mri/aseg/COR-.info",SUBJECTS_DIR,subject);
if (!fio_FileExistsReadable(tmpstr))
{
printf("ERROR: cannot find aseg\n");
exit(1);
}
else
{
sprintf(tmpstr,"%s/%s/mri/aseg/",SUBJECTS_DIR,subject);
}
}
}
printf("\nLoading aseg from %s\n",tmpstr);
ASeg = MRIread(tmpstr);
if (ASeg == NULL)
{
printf("ERROR: loading aseg %s\n",tmpstr);
exit(1);
}
mritmp = MRIchangeType(ASeg,MRI_INT,0,0,1);
MRIfree(&ASeg);
ASeg = mritmp;
if (CtxSegFile)
{
printf("Loading Ctx Seg File %s\n",CtxSegFile);
CtxSeg = MRIread(CtxSegFile);
if (CtxSeg == NULL)
{
exit(1);
}
}
AParc = MRIclone(ASeg,NULL);
if (OutDistFile != NULL)
{
Dist = MRIclone(ASeg,NULL);
mritmp = MRIchangeType(Dist,MRI_FLOAT,0,0,0);
if (mritmp == NULL)
{
printf("ERROR: could change type\n");
exit(1);
}
MRIfree(&Dist);
Dist = mritmp;
}
Vox2RAS = MRIxfmCRS2XYZtkreg(ASeg);
printf("ASeg Vox2RAS: -----------\n");
MatrixPrint(stdout,Vox2RAS);
printf("-------------------------\n");
CRS = MatrixAlloc(4,1,MATRIX_REAL);
CRS->rptr[4][1] = 1;
RAS = MatrixAlloc(4,1,MATRIX_REAL);
RAS->rptr[4][1] = 1;
if (crsTest)
{
printf("Testing point %d %d %d\n",ctest,rtest,stest);
err = FindClosestLRWPVertexNo(ctest,rtest,stest,
&lhwvtx, &lhpvtx,
&rhwvtx, &rhpvtx, Vox2RAS,
lhwhite, lhpial,
rhwhite, rhpial,
lhwhite_hash, lhpial_hash,
rhwhite_hash, rhpial_hash);
printf("Result: err = %d\n",err);
exit(err);
}
printf("\nLabeling Slice\n");
nctx = 0;
annot = 0;
annotid = 0;
nbrute = 0;
// Go through each voxel in the aseg
for (c=0; c < ASeg->width; c++)
{
printf("%3d ",c);
if (c%20 ==19)
{
printf("\n");
}
fflush(stdout);
for (r=0; r < ASeg->height; r++)
{
for (s=0; s < ASeg->depth; s++)
{
asegid = MRIgetVoxVal(ASeg,c,r,s,0);
if (asegid == 3 || asegid == 42)
{
IsCortex = 1;
}
else
{
IsCortex = 0;
}
if (asegid >= 77 && asegid <= 82)
{
IsHypo = 1;
}
else
{
IsHypo = 0;
}
if (asegid == 2 || asegid == 41)
{
IsWM = 1;
}
else
{
IsWM = 0;
}
if (IsHypo && LabelHypoAsWM && MRIgetVoxVal(filled,c,r,s,0))
{
IsWM = 1;
}
// integrate surface information
//
// Only Do This for GM,WM or Unknown labels in the ASEG !!!
//
// priority is given to the ribbon computed from the surface
// namely
// ribbon=GM => GM
// aseg=GM AND ribbon=WM => WM
// ribbon=UNKNOWN => UNKNOWN
if (UseNewRibbon && ( IsCortex || IsWM || asegid==0 ) )
{
RibbonVal = MRIgetVoxVal(RibbonSeg,c,r,s,0);
MRIsetVoxVal(ASeg,c,r,s,0, RibbonVal);
if (RibbonVal==2 || RibbonVal==41)
{
IsWM = 1;
IsCortex = 0;
}
else if (RibbonVal==3 || RibbonVal==42)
{
IsWM = 0;
IsCortex = 1;
}
if (RibbonVal==0)
{
IsWM = 0;
IsCortex = 0;
}
}
// If it's not labeled as cortex or wm in the aseg, skip
if (!IsCortex && !IsWM)
{
continue;
}
// If it's wm but not labeling wm, skip
if (IsWM && !LabelWM)
{
continue;
}
// Check whether this point is in the ribbon
if (UseRibbon)
{
lhRibbonVal = MRIgetVoxVal(lhRibbon,c,r,s,0);
rhRibbonVal = MRIgetVoxVal(rhRibbon,c,r,s,0);
if (IsCortex)
{
// ASeg says it's in cortex
if (lhRibbonVal < 0.5 && rhRibbonVal < 0.5)
{
// but it is not part of the ribbon,
// so set it to unknown (0) and go to the next voxel.
MRIsetVoxVal(ASeg,c,r,s,0,0);
continue;
}
}
}
// Convert the CRS to RAS
CRS->rptr[1][1] = c;
CRS->rptr[2][1] = r;
CRS->rptr[3][1] = s;
RAS = MatrixMultiply(Vox2RAS,CRS,RAS);
vtx.x = RAS->rptr[1][1];
vtx.y = RAS->rptr[2][1];
vtx.z = RAS->rptr[3][1];
// Get the index of the closest vertex in the
// lh.white, lh.pial, rh.white, rh.pial
if (UseHash)
{
lhwvtx = MHTfindClosestVertexNo(lhwhite_hash,lhwhite,&vtx,&dlhw);
lhpvtx = MHTfindClosestVertexNo(lhpial_hash, lhpial, &vtx,&dlhp);
rhwvtx = MHTfindClosestVertexNo(rhwhite_hash,rhwhite,&vtx,&drhw);
rhpvtx = MHTfindClosestVertexNo(rhpial_hash, rhpial, &vtx,&drhp);
if (lhwvtx < 0 && lhpvtx < 0 && rhwvtx < 0 && rhpvtx < 0)
{
/*
printf(" Could not map to any surface with hash table:\n");
printf(" crs = %d %d %d, ras = %6.4f %6.4f %6.4f \n",
c,r,s,vtx.x,vtx.y,vtx.z);
printf(" Using brute force search %d ... \n",nbrute);
fflush(stdout);
*/
lhwvtx = MRISfindClosestVertex(lhwhite,vtx.x,vtx.y,vtx.z,&dlhw);
lhpvtx = MRISfindClosestVertex(lhpial,vtx.x,vtx.y,vtx.z,&dlhp);
rhwvtx = MRISfindClosestVertex(rhwhite,vtx.x,vtx.y,vtx.z,&drhw);
rhpvtx = MRISfindClosestVertex(rhpial,vtx.x,vtx.y,vtx.z,&drhp);
nbrute ++;
//exit(1);
}
}
else
{
lhwvtx = MRISfindClosestVertex(lhwhite,vtx.x,vtx.y,vtx.z,&dlhw);
lhpvtx = MRISfindClosestVertex(lhpial,vtx.x,vtx.y,vtx.z,&dlhp);
rhwvtx = MRISfindClosestVertex(rhwhite,vtx.x,vtx.y,vtx.z,&drhw);
rhpvtx = MRISfindClosestVertex(rhpial,vtx.x,vtx.y,vtx.z,&drhp);
}
if (lhwvtx < 0)
{
dlhw = 1000000000000000.0;
}
if (lhpvtx < 0)
{
dlhp = 1000000000000000.0;
}
if (rhwvtx < 0)
{
drhw = 1000000000000000.0;
}
if (rhpvtx < 0)
{
drhp = 1000000000000000.0;
}
if (dlhw <= dlhp && dlhw < drhw && dlhw < drhp && lhwvtx >= 0)
{
annot = lhwhite->vertices[lhwvtx].annotation;
hemi = 1;
if (lhwhite->ct)
{
CTABfindAnnotation(lhwhite->ct, annot, &annotid);
}
else
{
annotid = annotation_to_index(annot);
}
dmin = dlhw;
}
if (dlhp < dlhw && dlhp < drhw && dlhp < drhp && lhpvtx >= 0)
{
annot = lhwhite->vertices[lhpvtx].annotation;
hemi = 1;
if (lhwhite->ct)
{
CTABfindAnnotation(lhwhite->ct, annot, &annotid);
}
else
{
annotid = annotation_to_index(annot);
}
dmin = dlhp;
}
if (drhw < dlhp && drhw < dlhw && drhw <= drhp && rhwvtx >= 0)
{
annot = rhwhite->vertices[rhwvtx].annotation;
hemi = 2;
if (rhwhite->ct)
{
CTABfindAnnotation(rhwhite->ct, annot, &annotid);
}
else
{
annotid = annotation_to_index(annot);
}
dmin = drhw;
}
if (drhp < dlhp && drhp < drhw && drhp < dlhw && rhpvtx >= 0)
{
annot = rhwhite->vertices[rhpvtx].annotation;
hemi = 2;
if (rhwhite->ct)
{
CTABfindAnnotation(rhwhite->ct, annot, &annotid);
}
else
{
annotid = annotation_to_index(annot);
}
dmin = drhp;
}
// Sometimes the annotation will be "none" indicated by
// annotid = -1. We interpret this as "unknown".
if (annotid == -1)
{
annotid = 0;
}
// why was this here in the first place?
/*
if (annotid == 0 &&
lhwvtx >= 0 &&
lhpvtx >= 0 &&
rhwvtx >= 0 &&
rhpvtx >= 0) {
printf("%d %d %d %d\n",
lhwhite->vertices[lhwvtx].ripflag,
lhpial->vertices[lhpvtx].ripflag,
rhwhite->vertices[rhwvtx].ripflag,
rhpial->vertices[rhpvtx].ripflag);
} */
if ( IsCortex && hemi == 1)
{
segval = annotid+1000 + baseoffset; //ctx-lh
}
if ( IsCortex && hemi == 2)
{
segval = annotid+2000 + baseoffset; //ctx-rh
}
if (!IsCortex && hemi == 1)
{
segval = annotid+3000 + baseoffset; // wm-lh
}
if (!IsCortex && hemi == 2)
{
segval = annotid+4000 + baseoffset; // wm-rh
}
if (!IsCortex && dmin > dmaxctx && hemi == 1)
{
segval = 5001;
}
if (!IsCortex && dmin > dmaxctx && hemi == 2)
{
segval = 5002;
}
// This is a hack for getting the right cortical seg with --rip-unknown
// The aparc+aseg should be passed as CtxSeg.
if (IsCortex && CtxSeg)
{
segval = MRIgetVoxVal(CtxSeg,c,r,s,0);
}
MRIsetVoxVal(ASeg,c,r,s,0,segval);
MRIsetVoxVal(AParc,c,r,s,0,annot);
if (OutDistFile != NULL)
{
MRIsetVoxVal(Dist,c,r,s,0,dmin);
}
if (debug || annotid == -1)
{
// Gets here when there is no label at the found vertex.
// This is different than having a vertex labeled as "unknown"
if (!debug)
{
continue;
}
printf("\n");
printf("Found closest vertex, but it has no label.\n");
printf("aseg id = %d\n",asegid);
printf("crs = %d %d %d, ras = %6.4f %6.4f %6.4f \n",
c,r,s,vtx.x,vtx.y,vtx.z);
if (lhwvtx > 0) printf("lhw %d %7.5f %6.4f %6.4f %6.4f\n",
lhwvtx, dlhw,
lhwhite->vertices[lhwvtx].x,
lhwhite->vertices[lhwvtx].y,
lhwhite->vertices[lhwvtx].z);
if (lhpvtx > 0) printf("lhp %d %7.5f %6.4f %6.4f %6.4f\n",
lhpvtx, dlhp,
lhpial->vertices[lhpvtx].x,
lhpial->vertices[lhpvtx].y,
lhpial->vertices[lhpvtx].z);
if (rhwvtx > 0) printf("rhw %d %7.5f %6.4f %6.4f %6.4f\n",
rhwvtx, drhw,
rhwhite->vertices[rhwvtx].x,
rhwhite->vertices[rhwvtx].y,
rhwhite->vertices[rhwvtx].z);
if (rhpvtx > 0) printf("rhp %d %7.5f %6.4f %6.4f %6.4f\n",
rhpvtx, drhp,
rhpial->vertices[rhpvtx].x,
rhpial->vertices[rhpvtx].y,
rhpial->vertices[rhpvtx].z);
printf("annot = %d, annotid = %d\n",annot,annotid);
CTABprintASCII(lhwhite->ct,stdout);
continue;
}
nctx++;
}
}
}
printf("nctx = %d\n",nctx);
printf("Used brute-force search on %d voxels\n",nbrute);
if (FixParaHipWM)
{
/* This is a bit of a hack. There are some vertices that have been
ripped because they are "unkown". When the above alorithm finds
these, it searches for the closest known vertex. If this is
less than dmax away, then the wm voxel gets labeled
accordingly. However, there are often some voxels near
ventralDC that are just close enough in 3d space to parahip to
get labeled even though they are very far away along the
surface. These voxels end up forming an island. CCSegment()
will eliminate any islands. Unforunately, CCSegment() uses
6-neighbor (face) definition of connectedness, so some voxels
may be eliminated.
*/
printf("Fixing Parahip LH WM\n");
CCSegment(ASeg, 3016, 5001); //3016 = lhphwm, 5001 = unsegmented WM left
printf("Fixing Parahip RH WM\n");
CCSegment(ASeg, 4016, 5002); //4016 = rhphwm, 5002 = unsegmented WM right
}
printf("Writing output aseg to %s\n",OutASegFile);
MRIwrite(ASeg,OutASegFile);
if (OutAParcFile != NULL)
{
printf("Writing output aparc to %s\n",OutAParcFile);
MRIwrite(AParc,OutAParcFile);
}
if (OutDistFile != NULL)
{
printf("Writing output dist file to %s\n",OutDistFile);
MRIwrite(Dist,OutDistFile);
}
return(0);
}
int
main(int argc, char *argv[])
{
char **av, *in_fname, *out_fname ;
int ac, nargs, i, label ;
MRI *mri_in, *mri_out, *mri_kernel, *mri_smoothed ;
/* rkt: check for and handle version tag */
nargs = handle_version_option
(argc, argv,
"$Id: mri_extract_label.c,v 1.13 2011/03/02 00:04:15 nicks Exp $",
"$Name: $");
if (nargs && argc - nargs == 1)
exit (0);
argc -= nargs;
Progname = argv[0] ;
ErrorInit(NULL, NULL, NULL) ;
DiagInit(NULL, NULL, NULL) ;
ac = argc ;
av = argv ;
for ( ; argc > 1 && ISOPTION(*argv[1]) ; argc--, argv++)
{
nargs = get_option(argc, argv) ;
argc -= nargs ;
argv += nargs ;
}
if (argc < 4)
usage_exit() ;
in_fname = argv[1] ;
out_fname = argv[argc-1] ;
printf("reading volume from %s...\n", in_fname) ;
mri_in = MRIread(in_fname) ;
if (!mri_in)
ErrorExit(ERROR_NOFILE, "%s: could not read MRI volume %s", Progname,
in_fname) ;
if (out_like_fname)
{
MRI *mri_tmp = MRIread(out_like_fname) ;
if (!mri_tmp)
ErrorExit
(ERROR_NOFILE,
"%s: could not read template volume from %s",
out_like_fname) ;
mri_out = MRIalloc(mri_tmp->width,
mri_tmp->height,
mri_tmp->depth,
mri_tmp->type) ;
/* MRIcopyHeader(mri_tmp, mri_out) ;*/
MRIfree(&mri_tmp) ;
}
else
mri_out = MRIclone(mri_in, NULL) ;
for (i = 2 ; i < argc-1 ; i++)
{
label = atoi(argv[i]) ;
printf("extracting label %d (%s)\n", label, cma_label_to_name(label)) ;
extract_labeled_image(mri_in, transform, label, mri_out) ;
}
if (!FZERO(sigma))
{
printf("smoothing extracted volume...\n") ;
mri_kernel = MRIgaussian1d(sigma, 10*sigma) ;
mri_smoothed = MRIconvolveGaussian(mri_out, NULL, mri_kernel) ;
MRIfree(&mri_out) ;
mri_out = mri_smoothed ;
}
/* removed for gcc3.3
* vsprintf(out_fname, out_fname, (va_list) &label) ;
*/
if (dilate > 0)
{
int i ;
printf("dilating output volume %d times...\n", dilate) ;
for (i = 0 ; i < dilate ; i++)
MRIdilate(mri_out, mri_out) ;
}
if (erode > 0)
{
int i ;
printf("eroding output volume %d times...\n", erode) ;
for (i = 0 ; i < erode ; i++)
MRIerode(mri_out, mri_out) ;
}
printf("writing output to %s.\n", out_fname) ;
MRIwrite(mri_out, out_fname) ;
if (exit_none_found && (nvoxels == 0))
{
printf("No voxels with specified label were found!\n");
exit(1);
}
exit(0) ;
return(0) ; /* for ansi */
}
int
main(int argc, char *argv[]) {
char **av, *hemi, *subject_name, *cp, fname[STRLEN];
char *parc_name, *annot_name ;
int ac, nargs, vno, i ;
MRI_SURFACE *mris ;
MRI *mri_parc ;
VERTEX *v ;
double d ;
Real x, y, z, xw, yw, zw ;
/* rkt: check for and handle version tag */
nargs = handle_version_option (argc, argv,
"$Id: mris_sample_parc.c,v 1.31 2016/12/11 14:33:38 fischl Exp $", "$Name: $");
if (nargs && argc - nargs == 1)
exit (0);
argc -= nargs;
Progname = argv[0] ;
ErrorInit(NULL, NULL, NULL) ;
DiagInit(NULL, NULL, NULL) ;
ac = argc ;
av = argv ;
for ( ; argc > 1 && ISOPTION(*argv[1]) ; argc--, argv++) {
nargs = get_option(argc, argv) ;
argc -= nargs ;
argv += nargs ;
}
if (argc < 4)
usage_exit() ;
subject_name = argv[1] ;
hemi = argv[2] ;
parc_name = argv[3] ;
annot_name = argv[4] ;
if (strlen(sdir) == 0) /* if not specified explicitly as option */
{
cp = getenv("SUBJECTS_DIR") ;
if (!cp)
ErrorExit(ERROR_BADPARM,
"%s: SUBJECTS_DIR not defined in environment.\n", Progname) ;
strcpy(sdir, cp) ;
}
if (parc_name[0] == '/') // full path specified
strcpy(fname, parc_name) ;
else
sprintf(fname, "%s/%s/mri/%s", sdir, subject_name, parc_name) ;
printf("reading parcellation volume from %s...\n", fname) ;
mri_parc = MRIread(fname) ;
if (!mri_parc)
ErrorExit(ERROR_NOFILE, "%s: could not read input volume %s",
Progname, fname) ;
if (mask_fname) {
MRI *mri_mask, *mri_tmp ;
mri_tmp = MRIread(mask_fname) ;
if (mri_tmp == NULL)
ErrorExit(ERROR_BADPARM, "%s: could not load mask volume %s", Progname, mask_fname) ;
mri_mask = MRIclone(mri_tmp, NULL) ;
MRIcopyLabel(mri_tmp, mri_mask, mask_val) ;
MRIdilate(mri_mask, mri_mask) ;
MRIdilate(mri_mask, mri_mask) ;
MRIdilate(mri_mask, mri_mask) ;
MRIdilate(mri_mask, mri_mask) ;
MRIfree(&mri_tmp) ;
mri_tmp = MRIclone(mri_parc, NULL) ;
MRIcopyLabeledVoxels(mri_parc, mri_mask, mri_tmp, mask_val) ;
MRIfree(&mri_parc) ;
mri_parc = mri_tmp ;
if (Gdiag & DIAG_WRITE && DIAG_VERBOSE_ON)
MRIwrite(mri_parc, "p.mgz") ;
MRIfree(&mri_mask) ;
}
for (i = 0 ; i < ntrans ; i++) {
MRIreplaceValues(mri_parc, mri_parc, trans_in[i], trans_out[i]) ;
}
sprintf(fname, "%s/%s/surf/%s.%s", sdir, subject_name, hemi, surf_name) ;
printf("reading input surface %s...\n", fname) ;
mris = MRISread(fname) ;
if (!mris)
ErrorExit(ERROR_NOFILE, "%s: could not read surface file %s",
Progname, fname) ;
MRISsaveVertexPositions(mris, ORIGINAL_VERTICES) ;
MRIScomputeMetricProperties(mris) ;
if (avgs > 0)
MRISaverageVertexPositions(mris, avgs) ;
if (FZERO(proj_mm)) {
if (MRISreadCurvatureFile(mris, thickness_name) != NO_ERROR)
ErrorExit(ERROR_NOFILE, "%s: could not read thickness file %s",
Progname, thickness_name) ;
}
if (color_table_fname) {
mris->ct = CTABreadASCII(color_table_fname) ;
if (mris->ct == NULL)
ErrorExit(ERROR_NOFILE, "%s: could not read color file %s",
Progname, color_table_fname) ;
}
if (sample_from_vol_to_surf) // sample from volume to surface */
{
MRIsampleParcellationToSurface(mris, mri_parc) ;
} else /* sample from surface to volume */
{
for (vno = 0 ; vno < mris->nvertices ; vno++) {
v = &mris->vertices[vno] ;
if (v->ripflag)
continue ;
if (vno == Gdiag_no)
DiagBreak() ;
if (!FZERO(proj_mm))
d = proj_mm ;
else
d = v->curv*proj_frac ; /* halfway out */
x = v->x+d*v->nx ;
y = v->y+d*v->ny ;
z = v->z+d*v->nz ;
MRIsurfaceRASToVoxel(mri_parc, x, y, z, &xw, &yw, &zw) ;
v->annotation = v->val =
MRIfindNearestNonzero(mri_parc, wsize, xw, yw, zw, ((float)wsize-1)/2) ;
if (v->val == 0xffffffff)
DiagBreak() ;
}
}
if (replace_label)
replace_vertices_with_label(mris, mri_parc, replace_label, proj_mm);
if (unknown_label >= 0) {
LABEL **labels, *label ;
int nlabels, i, biggest_label, most_vertices, nzero ;
#define TMP_LABEL 1000
for (nzero = vno = 0 ; vno < mris->nvertices ; vno++) {
v = &mris->vertices[vno] ;
if (v->annotation == 0) {
v->annotation = TMP_LABEL;
nzero++ ;
}
}
printf("%d unknown vertices found\n", nzero) ;
MRISsegmentAnnotated(mris, &labels, &nlabels, 10) ;
most_vertices = 0 ;
biggest_label = -1 ;
for (i = 0 ; i < nlabels ; i++) {
label = labels[i] ;
if (mris->vertices[label->lv[0].vno].annotation == TMP_LABEL) {
if (label->n_points > most_vertices) {
biggest_label = i ;
most_vertices = label->n_points ;
}
}
}
if (biggest_label >= 0) {
label = labels[biggest_label] ;
printf("replacing label # %d with %d vertices "
"(vno=%d) with label %d\n",
biggest_label,
label->n_points,
label->lv[0].vno,
unknown_label) ;
for (i = 0 ; i < label->n_points ; i++) {
v = &mris->vertices[label->lv[i].vno] ;
v->annotation = v->val = unknown_label ;
}
}
for (nzero = vno = 0 ; vno < mris->nvertices ; vno++) {
v = &mris->vertices[vno] ;
if (v->annotation == TMP_LABEL) {
v->annotation = 0;
nzero++ ;
}
}
printf("after replacement, %d unknown vertices found\n", nzero) ;
MRISmodeFilterZeroVals(mris) ; /* get rid of the rest
of the unknowns by mode filtering */
for (i = 0 ; i < nlabels ; i++)
LabelFree(&labels[i]) ;
free(labels) ;
}
MRIScopyValsToAnnotations(mris) ;
if (fix_topology != 0)
fix_label_topology(mris, fix_topology) ;
if (mode_filter) {
printf("mode filtering sample labels...\n") ;
#if 0
MRISmodeFilterZeroVals(mris) ;
#else
MRISmodeFilterVals(mris, mode_filter) ;
#endif
for (vno = 0 ; vno < mris->nvertices ; vno++) {
v = &mris->vertices[vno] ;
if (v->ripflag)
continue ;
v->annotation = v->val ;
}
}
/* this will fill in the v->annotation field from the v->val ones */
translate_indices_to_annotations(mris, translation_fname) ;
if (label_index >= 0)
{
int index ;
LABEL *area ;
printf("writing label to %s...\n", annot_name) ;
MRISclearMarks(mris) ;
for (vno = 0 ; vno < mris->nvertices ; vno++)
{
if (vno == Gdiag_no)
DiagBreak() ;
v = &mris->vertices[vno] ;
if (v->annotation > 0)
DiagBreak() ;
CTABfindAnnotation(mris->ct, v->annotation, &index);
if (index == label_index)
v->marked = 1 ;
}
area = LabelFromMarkedSurface(mris) ;
if (nclose > 0)
{
LabelDilate(area, mris, nclose, CURRENT_VERTICES) ;
LabelErode(area, mris, nclose) ;
}
LabelWrite(area, annot_name) ;
}
else
{
printf("writing annotation to %s...\n", annot_name) ;
MRISwriteAnnotation(mris, annot_name) ;
}
/* MRISreadAnnotation(mris, fname) ;*/
exit(0) ;
return(0) ; /* for ansi */
}
/*---------------------------------------------------------------*/
int main(int argc, char **argv) {
int n, v, c;
FILE *fp;
char *covarname;
char SumFile[2000];
char DatFile[2000];
char MatFile[2000];
char OutGDFile[2000];
int nargs;
/* rkt: check for and handle version tag */
nargs = handle_version_option (argc, argv, "$Id: mri_gdfglm.c,v 1.8.2.1 2011/05/05 15:29:51 greve Exp $", "$Name: stable5 $");
if (nargs && argc - nargs == 1)
exit (0);
argc -= nargs;
Progname = argv[0] ;
argc --;
argv++;
ErrorInit(NULL, NULL, NULL) ;
DiagInit(NULL, NULL, NULL) ;
if (argc == 0) usage_exit();
printf("\n\n");
printf("%s ",Progname);
for (n=0; n < argc; n++) printf("%s ",argv[n]);
printf("\n\n");
printf("%s\n\n",vcid);
parse_commandline(argc, argv);
check_options();
dump_options(stdout);
X = gdfMatrixDODS(fsgd,NULL);
if (X==NULL) exit(1);
if (debug) MatrixPrint(stdout,X);
Xnorm = MatrixNormalizeCol(X,NULL,NULL);
Xcondition = sqrt(MatrixNSConditionNumber(Xnorm));
MatrixFree(&Xnorm);
printf("INFO: Normalized Design Matrix Condition Number is %g\n",
Xcondition);
if (Xcondition > 100000) {
printf("ERROR: Design matrix is badly conditioned, check for linear\n"
"dependency between columns (ie, two or more columns \n"
"that add up to another column).\n\n");
exit(1);
}
printf("Extracting DepVar\n");
y = DVTgetDepVar(dvt,nDepVarList,DepVarList,wDepVar);
printf("Performing Estimation\n");
pinvX = MatrixPseudoInverse(X,NULL);
beta = MatrixMultiply(pinvX,y,NULL);
yhat = MatrixMultiply(X,beta,NULL);
r = MatrixSubtract(y,yhat,NULL);
dof = X->rows-X->cols;
rvar = VectorVar(r, &rmean);
rvar = rvar * (X->rows-1)/dof;
printf("Beta: -----------------\n");
MatrixPrint(stdout,beta);
printf("---------------------------------\n\n");
printf("rvar = %g, rstd = %g\n",rvar,sqrt(rvar));
C = gdfContrastDODS(fsgd, wClass, wCovar);
printf("C: -----------------\n");
MatrixPrint(stdout,C);
printf("---------------------------------\n\n");
ces = MatrixMultiply(C,beta,NULL);
vmf = ContrastVMF(X,C);
tval = ces->rptr[1][1]/sqrt(rvar*vmf);
sigtval = sigt(tval, rint(dof));
printf("ces = %g, vmf = %g, t = %g, sigt = %g\n",
ces->rptr[1][1],vmf,tval,sigtval);
sprintf(SumFile,"%s.sum",OutBase);
fp = fopen(SumFile,"w");
fprintf(fp,"mri_gdfglm summary file\n\n");
fprintf(fp,"Group Descriptor File %s\n",GDFile);
fprintf(fp,"Dependent Variable File %s\n",DVTFile);
fprintf(fp,"Dependent Variable Weights: ");
if (wDepVar == NULL)
fprintf(fp," all 1s\n");
else {
fprintf(fp,"\n");
for (n=0; n < nwDepVar; n++)
fprintf(fp," %s %g\n",DepVarList[n],wDepVar[n]);
}
fprintf(fp,"\n");
fprintf(fp,"Class Contrast Weights: ");
if (nwClass == 0)
fprintf(fp," all 1s\n");
else {
fprintf(fp,"\n");
for (n=0; n < nwClass; n++)
fprintf(fp," %s %g\n",fsgd->classlabel[n],wClass[n]);
}
fprintf(fp,"\n");
fprintf(fp,"Covar Contrast Weights: ");
if (nwCovar == 0)
if (!TestOffset) fprintf(fp," all 1s\n");
else fprintf(fp," all 0s\n");
else {
fprintf(fp,"\n");
for (n=0; n < nwCovar; n++)
fprintf(fp," %s %g",CovarList[n],wCovar[n]);
fprintf(fp,"\n");
}
fprintf(fp,"TestOffset = %d\n",TestOffset);
fprintf(fp,"\n");
fprintf(fp,"Parameter Estimates and Contrast Weighting:\n\n");
n = 0;
for (v=0; v < fsgd->nvariables+1; v++) {
if (v==0) covarname = "Offset";
else covarname = fsgd->varlabel[v-1];
for (c=0; c < fsgd->nclasses; c++) {
fprintf(fp,"%-10s %-10s %12.5f %5.2f\n",fsgd->classlabel[c],
covarname,beta->rptr[n+1][1],C->rptr[1][n+1]);
n++;
}
fprintf(fp,"\n");
}
fprintf(fp,"\n");
fprintf(fp,"Residual Variance %g\n",rvar);
fprintf(fp,"Residual StdDev %g\n",sqrt(rvar));
fprintf(fp,"DOF %g\n",dof);
fprintf(fp,"\n");
fprintf(fp,"Contrast Effect Size %g\n",ces->rptr[1][1]);
fprintf(fp,"Variance Reduction Factor %g\n",1/vmf);
fprintf(fp,"t-Ratio %g\n",tval);
fprintf(fp,"Significance %g\n",sigtval);
fprintf(fp,"\n");
fclose(fp);
/*----------------------------------------*/
sprintf(DatFile,"%s.dat",OutBase);
fp = fopen(DatFile,"w");
for (n=0; n < fsgd->ninputs; n++) {
fprintf(fp,"%2d ",n);
if (KeepSubjId) fprintf(fp,"%s",fsgd->subjid[n]);
for (v=0; v < fsgd->nvariables; v++)
fprintf(fp," %g",fsgd->varvals[n][v]);
fprintf(fp," %g %g",y->rptr[n+1][1],yhat->rptr[n+1][1]);
fprintf(fp,"\n");
}
fclose(fp);
/*----------------------------------------*/
sprintf(MatFile,"%s.mat",OutBase);
all = MatrixHorCat(X,y,NULL);
all = MatrixHorCat(all,yhat,NULL);
all = MatrixHorCat(all,r,NULL);
MatlabWrite(all,MatFile,"X");
/*----------------------------------------*/
sprintf(OutGDFile,"%s.gdf",OutBase);
fp = fopen(OutGDFile,"w");
gdfPrintHeader(fp,fsgd);
fclose(fp);
/*----------------------------------------*/
WriteAllClassDat(OutBase,fsgd,y,yhat,X,beta);
return(0);
}
int
main(int argc, char *argv[])
{
char **av, *in_fname,fname[STRLEN],hemi[10], path[STRLEN],
name[STRLEN],*cp ;
int ac, nargs, nhandles ;
MRI_SURFACE *mris ;
double ici, fi, var ;
/* rkt: check for and handle version tag */
nargs = handle_version_option
(argc, argv,
"$Id: mris_curvature.c,v 1.31 2011/03/02 00:04:30 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 < 2)
{
usage_exit() ;
}
in_fname = argv[1] ;
FileNamePath(in_fname, path) ;
FileNameOnly(in_fname, name) ;
cp = strchr(name, '.') ;
if (!cp)
ErrorExit(ERROR_BADPARM, "%s: could not scan hemisphere from '%s'",
Progname, fname) ;
strncpy(hemi, cp-2, 2) ;
hemi[2] = 0 ;
if (patch_flag) /* read the orig surface, then the patch file */
{
sprintf(fname, "%s/%s.orig", path, hemi) ;
mris = MRISfastRead(fname) ;
if (!mris)
ErrorExit(ERROR_NOFILE, "%s: could not read surface file %s",
Progname, in_fname) ;
if (Gdiag & DIAG_SHOW)
{
fprintf(stderr, "reading patch file %s...\n", in_fname) ;
}
if (MRISreadPatch(mris, in_fname) != NO_ERROR)
ErrorExit(ERROR_NOFILE, "%s: could not read patch file %s",
Progname, in_fname) ;
}
else /* just read the surface normally */
{
mris = MRISread(in_fname) ;
if (!mris)
ErrorExit(ERROR_NOFILE, "%s: could not read surface file %s",
Progname, in_fname) ;
}
MRISsetNeighborhoodSize(mris, nbrs) ;
if (nbhd_size > 0)
{
MRISsampleAtEachDistance(mris, nbhd_size, nbrs_per_distance) ;
}
if (max_mm > 0)
{
float ratio ;
MRISstoreMetricProperties(mris) ;
if (MRISreadCanonicalCoordinates(mris, "sphere") != NO_ERROR)
{
ErrorExit(ERROR_NOFILE,
"%s: could not read canonical coordinates from ?h.sphere",
Progname);
}
MRISsaveVertexPositions(mris, ORIGINAL_VERTICES) ;
MRISrestoreVertexPositions(mris, CANONICAL_VERTICES) ;
MRIScomputeMetricProperties(mris) ;
ratio = mris->orig_area / M_PI * mris->radius * mris->radius * 4.0 ;
ratio = mris->orig_area / mris->total_area ;
MRISscaleBrain(mris, mris, sqrt(ratio)) ;
MRISsaveVertexPositions(mris, CANONICAL_VERTICES) ;
MRISrestoreVertexPositions(mris, ORIGINAL_VERTICES) ;
MRIScomputeMetricProperties(mris) ;
MRIScomputeNeighbors(mris, max_mm) ;
}
if (param_file)
{
MRI_SP *mrisp ;
mrisp = MRISPread(param_file) ;
if (normalize_param)
{
MRISnormalizeFromParameterization(mrisp, mris, param_no) ;
}
else
{
MRISfromParameterization(mrisp, mris, param_no) ;
}
MRISPfree(&mrisp) ;
if (normalize)
{
MRISnormalizeCurvature(mris,which_norm) ;
}
sprintf(fname, "%s/%s%s.param", path,name,suffix) ;
fprintf(stderr, "writing parameterized curvature to %s...", fname) ;
MRISwriteCurvature(mris, fname) ;
fprintf(stderr, "done.\n") ;
}
else
{
MRIScomputeSecondFundamentalFormThresholded(mris, cthresh) ;
nhandles = nint(1.0 - mris->Ktotal / (4.0*M_PI)) ;
fprintf(stderr, "total integrated curvature = %2.3f*4pi (%2.3f) --> "
"%d handles\n", (float)(mris->Ktotal/(4.0f*M_PI)),
(float)mris->Ktotal, nhandles) ;
#if 0
fprintf(stderr, "0: k1 = %2.3f, k2 = %2.3f, H = %2.3f, K = %2.3f\n",
mris->vertices[0].k1, mris->vertices[0].k2,
mris->vertices[0].H, mris->vertices[0].K) ;
fprintf(stderr, "0: vnum = %d, v2num = %d, total=%d, area=%2.3f\n",
mris->vertices[0].vnum, mris->vertices[0].v2num,
mris->vertices[0].vtotal,mris->vertices[0].area) ;
#endif
MRIScomputeCurvatureIndices(mris, &ici, &fi);
var = MRIStotalVariation(mris) ;
fprintf(stderr,"ICI = %2.1f, FI = %2.1f, variation=%2.3f\n", ici, fi, var);
if (diff_flag)
{
MRISuseCurvatureDifference(mris) ;
MRISaverageCurvatures(mris, navgs) ;
sprintf(fname, "%s/%s%s.diff", path,name,suffix) ;
fprintf(stderr, "writing curvature difference to %s...", fname) ;
MRISwriteCurvature(mris, fname) ;
fprintf(stderr, "done.\n") ;
}
if (ratio_flag)
{
MRISuseCurvatureRatio(mris) ;
MRISaverageCurvatures(mris, navgs) ;
if (normalize)
{
MRISnormalizeCurvature(mris,which_norm) ;
}
sprintf(fname, "%s/%s%s.ratio", path,name,suffix) ;
fprintf(stderr, "writing curvature ratio to %s...", fname) ;
MRISwriteCurvature(mris, fname) ;
fprintf(stderr, "done.\n") ;
}
if (contrast_flag)
{
MRISuseCurvatureContrast(mris) ;
MRISaverageCurvatures(mris, navgs) ;
if (normalize)
{
MRISnormalizeCurvature(mris,which_norm) ;
}
sprintf(fname, "%s/%s%s.contrast", path,name,suffix) ;
fprintf(stderr, "writing curvature contrast to %s...", fname) ;
MRISwriteCurvature(mris, fname) ;
fprintf(stderr, "done.\n") ;
}
if (neg_flag)
{
int neg ;
if (mris->patch)
{
mris->status = MRIS_PLANE ;
}
MRIScomputeMetricProperties(mris) ;
neg = MRIScountNegativeTriangles(mris) ;
MRISuseNegCurvature(mris) ;
MRISaverageCurvatures(mris, navgs) ;
sprintf(fname, "%s/%s%s.neg", path,name,suffix) ;
fprintf(stderr, "writing negative vertex curvature to %s...", fname) ;
MRISwriteCurvature(mris, fname) ;
fprintf(stderr, "%d negative triangles\n", neg) ;
fprintf(stderr, "done.\n") ;
{
int vno, fno ;
VERTEX *v ;
FACE *f ;
for (vno = 0 ; vno < mris->nvertices ; vno++)
{
v = &mris->vertices[vno] ;
if (v->ripflag)
{
continue ;
}
neg = 0 ;
for (fno = 0 ; fno < v->num ; fno++)
{
f = &mris->faces[v->f[fno]] ;
if (f->area < 0.0f)
{
neg = 1 ;
}
}
if (neg)
{
fprintf(stdout, "%d\n", vno) ;
}
}
}
}
if (max_flag)
{
MRISuseCurvatureMax(mris) ;
MRISaverageCurvatures(mris, navgs) ;
if (normalize)
{
MRISnormalizeCurvature(mris,which_norm) ;
}
sprintf(fname, "%s/%s%s.max", path,name,suffix) ;
fprintf(stderr, "writing curvature maxima to %s...", fname) ;
MRISwriteCurvature(mris, fname) ;
fprintf(stderr, "done.\n") ;
}
if (min_flag)
{
MRISuseCurvatureMin(mris) ;
MRISaverageCurvatures(mris, navgs) ;
if (normalize)
{
MRISnormalizeCurvature(mris,which_norm) ;
}
sprintf(fname, "%s/%s%s.min", path,name,suffix) ;
fprintf(stderr, "writing curvature minima to %s...", fname) ;
MRISwriteCurvature(mris, fname) ;
fprintf(stderr, "done.\n") ;
}
if (stretch_flag)
{
MRISreadOriginalProperties(mris, NULL) ;
MRISuseCurvatureStretch(mris) ;
MRISaverageCurvatures(mris, navgs) ;
if (normalize)
{
MRISnormalizeCurvature(mris,which_norm) ;
}
sprintf(fname, "%s/%s%s.stretch", path,name,suffix) ;
fprintf(stderr, "writing curvature stretch to %s...", fname) ;
MRISwriteCurvature(mris, fname) ;
fprintf(stderr, "done.\n") ;
}
if (write_flag)
{
MRISuseGaussianCurvature(mris) ;
if (cthresh > 0)
{
MRIShistoThresholdCurvature(mris, cthresh) ;
}
MRISaverageCurvatures(mris, navgs) ;
sprintf(fname, "%s/%s%s.K", path,name, suffix) ;
fprintf(stderr, "writing Gaussian curvature to %s...", fname) ;
if (normalize)
{
MRISnormalizeCurvature(mris,which_norm) ;
}
MRISwriteCurvature(mris, fname) ;
MRISuseMeanCurvature(mris) ;
if (cthresh > 0)
{
MRIShistoThresholdCurvature(mris, cthresh) ;
}
MRISaverageCurvatures(mris, navgs) ;
if (normalize)
{
MRISnormalizeCurvature(mris,which_norm) ;
}
sprintf(fname, "%s/%s%s.H", path,name, suffix) ;
fprintf(stderr, "done.\nwriting mean curvature to %s...", fname) ;
MRISwriteCurvature(mris, fname) ;
fprintf(stderr, "done.\n") ;
}
}
exit(0) ;
return(0) ; /* for ansi */
}
int main(int argc, char *argv[]) {
char *inner_mris_fname_lh,*outer_mris_fname_lh,
*inner_mris_fname_rh,*outer_mris_fname_rh,
*input_mri_pref,*output_mri_pref,*mask_mri_pref;
MRI *mri,*mri_src,*mri_mask;
MRI_SURFACE *inner_mris_lh,*outer_mris_lh,*inner_mris_rh,*outer_mris_rh;
int nargs;
/* rkt: check for and handle version tag */
nargs = handle_version_option
(argc, argv,
"$Id: mri_partial_ribbon.c,v 1.11 2011/03/02 00:04:23 nicks Exp $",
"$Name: $");
if (nargs && argc - nargs == 1)
exit (0);
argc -= nargs;
/* Set command-line parameters */
if (argc < 7) {
usage();
exit(-1);
}
Progname=argv[0];
inner_mris_fname_lh=argv[1]; // lh.white
outer_mris_fname_lh=argv[2]; // lh.pial
inner_mris_fname_rh=argv[3]; // rh.white
outer_mris_fname_rh=argv[4]; // rh.pial
input_mri_pref=argv[5]; // volume
output_mri_pref=argv[6]; // output
if (argc==8)
mask_mri_pref=argv[7]; // cma mask
else
mask_mri_pref=NULL;
/* Read surface information from left inner surface file */
printf("Reading left inner surface file %s.\n",inner_mris_fname_lh);
inner_mris_lh=MRISread(inner_mris_fname_lh);
if (!inner_mris_lh) {
fprintf(stderr,"Could not read surface file %s.\n",inner_mris_fname_lh);
exit(1);
}
/* Read surface information from left outer surface file */
printf("Reading left outer surface file %s.\n",outer_mris_fname_lh);
outer_mris_lh=MRISread(outer_mris_fname_lh);
if (!outer_mris_lh) {
fprintf(stderr,"Could not read surface file %s.\n",outer_mris_fname_lh);
exit(1);
}
/* Read surface information from right inner surface file */
printf("Reading right inner surface file %s.\n",inner_mris_fname_rh);
inner_mris_rh=MRISread(inner_mris_fname_rh);
if (!inner_mris_rh) {
fprintf(stderr,"Could not read surface file %s.\n",inner_mris_fname_rh);
exit(1);
}
/* Read surface information from right outer surface file */
printf("Reading right outer surface file %s.\n",outer_mris_fname_rh);
outer_mris_rh=MRISread(outer_mris_fname_rh);
if (!outer_mris_rh) {
fprintf(stderr,"Could not read surface file %s.\n",outer_mris_fname_rh);
exit(1);
}
/* Read example volume from file */
printf("Reading MRI volume directory %s.\n",input_mri_pref);
mri_src=MRIread(input_mri_pref);
if (!mri_src) {
fprintf(stderr,"Could not read MRI volume directory %s.\n",input_mri_pref);
exit(1);
}
/* Read example volume from file */
if (argc==8) {
printf("Reading MRI volume directory %s.\n",mask_mri_pref);
mri_mask=MRIread(mask_mri_pref);
if (!mri_mask) {
fprintf(stderr,"Could not read MRI volume directory %s.\n",
mask_mri_pref);
exit(1);
}
} else
mri_mask=NULL;
/* Extract ribbon */
printf("Extracting ribbon.\n");
mri=MRISpartialribbon(inner_mris_lh,
outer_mris_lh,
inner_mris_rh,
outer_mris_rh,
mri_src,
NULL,
mri_mask);
/* Save MRI volume to directory */
printf("Writing volume file %s.\n",output_mri_pref);
MRIwrite(mri,output_mri_pref);
MRIfree(&mri);
MRIfree(&mri_src);
if (mri_mask)
MRIfree(&mri_mask);
MRISfree(&inner_mris_lh);
MRISfree(&outer_mris_lh);
MRISfree(&inner_mris_rh);
MRISfree(&outer_mris_rh);
return 0;
}
int main(int argc, char *argv[])
{
char **av;
MRI *mri_before, *mri_after, *mri_in, *mri_out;
int ac, nargs;
int width, height, depth, x, y, z, f,nframes ;
double v_before, v_after, v_in, v_out;
double gain;
Progname = argv[0];
nargs = handle_version_option (argc, argv, "$Id: mri_apply_INU.c,v 1.3 2011/03/02 00:04:55 nicks Exp $", "$Name: $");
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 != 3)
usage(1);
if (fname_before == NULL || fname_after == NULL)
{
printf("Use options to specify template volumes for gain field computation\n");
usage(1);
}
mri_in = MRIread(argv[1]) ;
if (!mri_in)
ErrorExit(ERROR_BADPARM, "%s: could not read input volume %s",
Progname, argv[1]) ;
mri_before = MRIread(fname_before) ;
if (!mri_before)
ErrorExit(ERROR_BADPARM, "%s: could not read tempate volume %s",
Progname, fname_before) ;
mri_after = MRIread(fname_after) ;
if (!mri_after)
ErrorExit(ERROR_BADPARM, "%s: could not read tempate volume %s",
Progname, fname_after) ;
if ((mri_in->width != mri_after->width) ||
(mri_in->height != mri_after->height) ||
(mri_in->depth != mri_after->depth) ||
(mri_in->width != mri_before->width) ||
(mri_in->height != mri_before->height) ||
(mri_in->depth != mri_before->depth)
)
ErrorExit(ERROR_BADPARM, "%s: three input volumes have different sizes \n", Progname);
mri_out = MRIclone(mri_in, NULL) ;
width = mri_in->width ;
height = mri_in->height ;
depth = mri_in->depth ;
nframes = mri_in->nframes ;
if (nframes == 0) nframes = 1;
for (f = 0 ; f < nframes ; f++)
{
for (z = 0 ; z < depth ; z++)
{
for (y = 0 ; y < height ; y++)
{
for (x = 0 ; x < width ; x++)
{
v_in = (double) MRIgetVoxVal(mri_in,x,y,z,f);
v_before = (double) MRIgetVoxVal(mri_before,x,y,z,f);
v_after = (double) MRIgetVoxVal(mri_after,x,y,z,f);
gain = v_after/(v_before + 1e-15);
v_out = gain*v_in;
MRIsetVoxVal(mri_out,x,y,z,f,(float)v_out);
}
}
}
}
printf("writing INU-corrected volume to %s...\n", argv[2]) ;
MRIwrite(mri_out, argv[2]);
MRIfree(&mri_in);
MRIfree(&mri_out);
MRIfree(&mri_before);
MRIfree(&mri_after);
exit(0);
} /* end main() */
int
main(int argc, char *argv[])
{
char **av, *output_fname ;
int ac, nargs, msec, mode=-1 ;
LABEL *area = NULL ;
MRI_SURFACE *mris ;
struct timeb then ;
MRI *mri_dist ;
/* rkt: check for and handle version tag */
nargs = handle_version_option
(argc, argv,
"$Id: mris_distance_transform.c,v 1.5 2013/04/12 20:59:17 fischl Exp $",
"$Name: $");
if (nargs && argc - nargs == 1)
exit (0);
argc -= nargs;
Gdiag |= DIAG_SHOW ;
Progname = argv[0] ;
ErrorInit(NULL, NULL, NULL) ;
DiagInit(NULL, NULL, NULL) ;
ac = argc ;
av = argv ;
for ( ; argc > 1 && ISOPTION(*argv[1]) ; argc--, argv++)
{
nargs = get_option(argc, argv) ;
argc -= nargs ;
argv += nargs ;
}
if (argc < 4)
usage_exit() ;
TimerStart(&then) ;
mris = MRISread(argv[1]) ;
if (mris == NULL)
ErrorExit(ERROR_NOFILE, "%s: could not read surface %s",
Progname, argv[1]) ;
if (vol)
{
/*
mri_template = MRIread(argv[2]) ;
if (!mri_template)
ErrorExit(ERROR_NOFILE, "%s: could not read MRI volume from %s\n", Progname, argv[2]) ;
*/
}
else
{
area = LabelRead(NULL, argv[2]) ;
if (area == NULL)
ErrorExit(ERROR_NOFILE, "%s: could not read label %s",
Progname, argv[2]) ;
if (anterior_dist > 0)
LabelCropAnterior(area, anterior_dist) ;
if (posterior_dist > 0)
LabelCropPosterior(area, posterior_dist) ;
}
if (stricmp(argv[3], "signed") == 0)
mode = DTRANS_MODE_SIGNED ;
else if (stricmp(argv[3], "unsigned") == 0)
mode = DTRANS_MODE_UNSIGNED ;
else if (stricmp(argv[3], "outside") == 0)
mode = DTRANS_MODE_OUTSIDE ;
else
{
print_usage() ;
ErrorExit(ERROR_BADPARM, "unrecognized mode choice %s\n", argv[3]) ;
}
output_fname = argv[4] ;
MRIScomputeMetricProperties(mris) ;
if (vol)
{
mri_dist = MRIScomputeDistanceToSurface(mris, NULL, 0.25) ;
MRIwrite(mri_dist, argv[4]) ;
}
else
{
MRIScomputeSecondFundamentalForm(mris) ;
if (normalize > 0)
{
normalize = sqrt(mris->total_area) ;
printf("normalizing surface distances by sqrt(%2.1f) = %2.1f\n", mris->total_area,normalize) ;
}
if (divide > 1)
{
int i ;
char fname[STRLEN], ext[STRLEN], base_name[STRLEN] ;
LABEL *area_division ;
FileNameExtension(output_fname, ext) ;
FileNameRemoveExtension(output_fname, base_name) ;
LabelMark(area, mris) ;
MRIScopyMarksToAnnotation(mris) ;
MRISsaveVertexPositions(mris, TMP_VERTICES) ;
if (MRISreadVertexPositions(mris, divide_surf_name) != NO_ERROR)
ErrorExit(ERROR_BADPARM, "%s: could not read vertex coords from %s", Progname, divide_surf_name) ;
MRIScomputeSecondFundamentalForm(mris) ;
MRISdivideAnnotationUnit(mris, 1, divide) ;
MRISrestoreVertexPositions(mris, TMP_VERTICES) ;
MRIScomputeSecondFundamentalForm(mris) ;
// MRISdivideAnnotationUnit sets the marked to be in [0,divide-1], make it [1,divide]
// make sure they are oriented along original a/p direction
#define MAX_UNITS 100
{
double cx[MAX_UNITS], cy[MAX_UNITS], cz[MAX_UNITS], min_a ;
int index, num[MAX_UNITS], new_index[MAX_UNITS], j, min_i ;
VERTEX *v ;
memset(num, 0, sizeof(num[0])*divide) ;
memset(cx, 0, sizeof(cx[0])*divide) ;
memset(cy, 0, sizeof(cy[0])*divide) ;
memset(cz, 0, sizeof(cz[0])*divide) ;
for (i = 0 ; i < area->n_points ; i++)
{
if (area->lv[i].vno < 0 || area->lv[i].deleted > 0)
continue ;
v = &mris->vertices[area->lv[i].vno] ;
v->marked++ ;
index = v->marked ;
cx[index] += v->x ;
cy[index] += v->y ;
cz[index] += v->z ;
num[index]++ ;
}
memset(new_index, 0, sizeof(new_index[0])*divide) ;
for (i = 1 ; i <= divide ; i++)
cy[i] /= num[i] ;
// order them from posterior to anterior
for (j = 1 ; j <= divide ; j++)
{
min_a = 1e10 ; min_i = 0 ;
for (i = 1 ; i <= divide ; i++)
{
if (cy[i] < min_a)
{
min_a = cy[i] ;
min_i = i ;
}
}
cy[min_i] = 1e10 ; // make it biggest so it won't be considered again
new_index[j] = min_i ;
}
for (i = 0 ; i < area->n_points ; i++)
{
if (area->lv[i].vno < 0 || area->lv[i].deleted > 0)
continue ;
v = &mris->vertices[area->lv[i].vno] ;
v->marked = new_index[v->marked] ;
}
}
for (i = 1 ; i <= divide ; i++)
{
area_division = LabelFromMarkValue(mris, i) ;
printf("performing distance transform on division %d with %d vertices\n",
i, area_division->n_points) ;
if (output_label)
{
sprintf(fname, "%s%d.label", base_name, i) ;
printf("writing %dth subdivision to %s\n", i, fname) ;
LabelWrite(area_division, fname);
}
MRISdistanceTransform(mris, area_division, mode) ;
sprintf(fname, "%s%d.%s", base_name, i, ext) ;
if (normalize > 0)
MRISmulVal(mris, 1.0/normalize) ;
MRISwriteValues(mris, fname) ;
}
}
else
{
MRISdistanceTransform(mris, area, mode) ;
if (normalize > 0)
MRISmulVal(mris, 1.0/normalize) ;
MRISwriteValues(mris, output_fname) ;
}
}
msec = TimerStop(&then) ;
fprintf(stderr,"distance transform took %2.1f minutes\n", (float)msec/(60*1000.0f));
exit(0) ;
return(0) ; /* for ansi */
}
/*---------------------------------------------------------------*/
int main(int argc, char *argv[]) {
int nargs, n, err;
char tmpstr[2000], *signstr=NULL,*SUBJECTS_DIR, fname[2000];
//char *OutDir = NULL;
RFS *rfs;
int nSmoothsPrev, nSmoothsDelta;
MRI *z, *zabs=NULL, *sig=NULL, *p=NULL;
int FreeMask = 0;
int nthSign, nthFWHM, nthThresh;
double sigmax, zmax, threshadj, csize, csizeavg, searchspace,avgvtxarea;
int csizen;
int nClusters, cmax,rmax,smax;
SURFCLUSTERSUM *SurfClustList;
struct timeb mytimer;
LABEL *clabel;
FILE *fp, *fpLog=NULL;
nargs = handle_version_option (argc, argv, vcid, "$Name: stable5 $");
if (nargs && argc - nargs == 1) exit (0);
argc -= nargs;
cmdline = argv2cmdline(argc,argv);
uname(&uts);
getcwd(cwd,2000);
Progname = argv[0] ;
argc --;
argv++;
ErrorInit(NULL, NULL, NULL) ;
DiagInit(NULL, NULL, NULL) ;
if (argc == 0) usage_exit();
parse_commandline(argc, argv);
check_options();
if (checkoptsonly) return(0);
dump_options(stdout);
if(LogFile){
fpLog = fopen(LogFile,"w");
if(fpLog == NULL){
printf("ERROR: opening %s\n",LogFile);
exit(1);
}
dump_options(fpLog);
}
if(SynthSeed < 0) SynthSeed = PDFtodSeed();
srand48(SynthSeed);
SUBJECTS_DIR = getenv("SUBJECTS_DIR");
// Create output directory
printf("Creating %s\n",OutTop);
err = fio_mkdirp(OutTop,0777);
if(err) exit(1);
for(nthFWHM=0; nthFWHM < nFWHMList; nthFWHM++){
for(nthThresh = 0; nthThresh < nThreshList; nthThresh++){
for(nthSign = 0; nthSign < nSignList; nthSign++){
if(SignList[nthSign] == 0) signstr = "abs";
if(SignList[nthSign] == +1) signstr = "pos";
if(SignList[nthSign] == -1) signstr = "neg";
sprintf(tmpstr,"%s/fwhm%02d/%s/th%02d",
OutTop,(int)round(FWHMList[nthFWHM]),
signstr,(int)round(10*ThreshList[nthThresh]));
sprintf(fname,"%s/%s.csd",tmpstr,csdbase);
if(fio_FileExistsReadable(fname)){
printf("ERROR: output file %s exists\n",fname);
if(fpLog) fprintf(fpLog,"ERROR: output file %s exists\n",fname);
exit(1);
}
err = fio_mkdirp(tmpstr,0777);
if(err) exit(1);
}
}
}
// Load the target surface
sprintf(tmpstr,"%s/%s/surf/%s.%s",SUBJECTS_DIR,subject,hemi,surfname);
printf("Loading %s\n",tmpstr);
surf = MRISread(tmpstr);
if(!surf) return(1);
// Handle masking
if(LabelFile){
printf("Loading label file %s\n",LabelFile);
sprintf(tmpstr,"%s/%s/label/%s.%s.label",
SUBJECTS_DIR,subject,hemi,LabelFile);
if(!fio_FileExistsReadable(tmpstr)){
printf(" Cannot find label file %s\n",tmpstr);
sprintf(tmpstr,"%s",LabelFile);
printf(" Trying label file %s\n",tmpstr);
if(!fio_FileExistsReadable(tmpstr)){
printf(" ERROR: cannot read or find label file %s\n",LabelFile);
exit(1);
}
}
printf("Loading %s\n",tmpstr);
clabel = LabelRead(NULL, tmpstr);
mask = MRISlabel2Mask(surf, clabel, NULL);
FreeMask = 1;
}
if(MaskFile){
printf("Loading %s\n",MaskFile);
mask = MRIread(MaskFile);
if(mask == NULL) exit(1);
}
if(mask && SaveMask){
sprintf(tmpstr,"%s/mask.mgh",OutTop);
printf("Saving mask to %s\n",tmpstr);
err = MRIwrite(mask,tmpstr);
if(err) exit(1);
}
// Compute search space
searchspace = 0;
nmask = 0;
for(n=0; n < surf->nvertices; n++){
if(mask && MRIgetVoxVal(mask,n,0,0,0) < 0.5) continue;
searchspace += surf->vertices[n].area;
nmask++;
}
printf("Found %d voxels in mask\n",nmask);
if(surf->group_avg_surface_area > 0)
searchspace *= (surf->group_avg_surface_area/surf->total_area);
printf("search space %g mm2\n",searchspace);
avgvtxarea = searchspace/nmask;
printf("average vertex area %g mm2\n",avgvtxarea);
// Determine how many iterations are needed for each FWHM
nSmoothsList = (int *) calloc(sizeof(int),nFWHMList);
for(nthFWHM=0; nthFWHM < nFWHMList; nthFWHM++){
nSmoothsList[nthFWHM] = MRISfwhm2niters(FWHMList[nthFWHM], surf);
printf("%2d %5.1f %4d\n",nthFWHM,FWHMList[nthFWHM],nSmoothsList[nthFWHM]);
if(fpLog) fprintf(fpLog,"%2d %5.1f %4d\n",nthFWHM,FWHMList[nthFWHM],nSmoothsList[nthFWHM]);
}
printf("\n");
// Allocate the CSDs
for(nthFWHM=0; nthFWHM < nFWHMList; nthFWHM++){
for(nthThresh = 0; nthThresh < nThreshList; nthThresh++){
for(nthSign = 0; nthSign < nSignList; nthSign++){
csd = CSDalloc();
sprintf(csd->simtype,"%s","null-z");
sprintf(csd->anattype,"%s","surface");
sprintf(csd->subject,"%s",subject);
sprintf(csd->hemi,"%s",hemi);
sprintf(csd->contrast,"%s","NA");
csd->seed = SynthSeed;
csd->nreps = nRepetitions;
csd->thresh = ThreshList[nthThresh];
csd->threshsign = SignList[nthSign];
csd->nullfwhm = FWHMList[nthFWHM];
csd->varfwhm = -1;
csd->searchspace = searchspace;
CSDallocData(csd);
csdList[nthFWHM][nthThresh][nthSign] = csd;
}
}
}
// Alloc the z map
z = MRIallocSequence(surf->nvertices, 1,1, MRI_FLOAT, 1);
// Set up the random field specification
rfs = RFspecInit(SynthSeed,NULL);
rfs->name = strcpyalloc("gaussian");
rfs->params[0] = 0;
rfs->params[1] = 1;
printf("Thresholds (%d): ",nThreshList);
for(n=0; n < nThreshList; n++) printf("%5.2f ",ThreshList[n]);
printf("\n");
printf("Signs (%d): ",nSignList);
for(n=0; n < nSignList; n++) printf("%2d ",SignList[n]);
printf("\n");
printf("FWHM (%d): ",nFWHMList);
for(n=0; n < nFWHMList; n++) printf("%5.2f ",FWHMList[n]);
printf("\n");
// Start the simulation loop
printf("\n\nStarting Simulation over %d Repetitions\n",nRepetitions);
if(fpLog) fprintf(fpLog,"\n\nStarting Simulation over %d Repetitions\n",nRepetitions);
TimerStart(&mytimer) ;
for(nthRep = 0; nthRep < nRepetitions; nthRep++){
msecTime = TimerStop(&mytimer) ;
printf("%5d %7.1f ",nthRep,(msecTime/1000.0)/60);
if(fpLog) {
fprintf(fpLog,"%5d %7.1f ",nthRep,(msecTime/1000.0)/60);
fflush(fpLog);
}
// Synthesize an unsmoothed z map
RFsynth(z,rfs,mask);
nSmoothsPrev = 0;
// Loop through FWHMs
for(nthFWHM=0; nthFWHM < nFWHMList; nthFWHM++){
printf("%d ",nthFWHM);
if(fpLog) {
fprintf(fpLog,"%d ",nthFWHM);
fflush(fpLog);
}
nSmoothsDelta = nSmoothsList[nthFWHM] - nSmoothsPrev;
nSmoothsPrev = nSmoothsList[nthFWHM];
// Incrementally smooth z
MRISsmoothMRI(surf, z, nSmoothsDelta, mask, z); // smooth z
// Rescale
RFrescale(z,rfs,mask,z);
// Slightly tortured way to get the right p-values because
// RFstat2P() computes one-sided, but I handle sidedness
// during thresholding.
// First, use zabs to get a two-sided pval bet 0 and 0.5
zabs = MRIabs(z,zabs);
p = RFstat2P(zabs,rfs,mask,0,p);
// Next, mult pvals by 2 to get two-sided bet 0 and 1
MRIscalarMul(p,p,2.0);
sig = MRIlog10(p,NULL,sig,1); // sig = -log10(p)
for(nthThresh = 0; nthThresh < nThreshList; nthThresh++){
for(nthSign = 0; nthSign < nSignList; nthSign++){
csd = csdList[nthFWHM][nthThresh][nthSign];
// If test is not ABS then apply the sign
if(csd->threshsign != 0) MRIsetSign(sig,z,0);
// Get the max stats
sigmax = MRIframeMax(sig,0,mask,csd->threshsign,
&cmax,&rmax,&smax);
zmax = MRIgetVoxVal(z,cmax,rmax,smax,0);
if(csd->threshsign == 0){
zmax = fabs(zmax);
sigmax = fabs(sigmax);
}
// Mask
if(mask) MRImask(sig,mask,sig,0.0,0.0);
// Surface clustering
MRIScopyMRI(surf, sig, 0, "val");
if(csd->threshsign == 0) threshadj = csd->thresh;
else threshadj = csd->thresh - log10(2.0); // one-sided test
SurfClustList = sclustMapSurfClusters(surf,threshadj,-1,csd->threshsign,
0,&nClusters,NULL);
// Actual area of cluster with max area
csize = sclustMaxClusterArea(SurfClustList, nClusters);
// Number of vertices of cluster with max number of vertices.
// Note: this may be a different cluster from above!
csizen = sclustMaxClusterCount(SurfClustList, nClusters);
// Area of this cluster based on average vertex area. This just scales
// the number of vertices.
csizeavg = csizen * avgvtxarea;
if(UseAvgVtxArea) csize = csizeavg;
// Store results
csd->nClusters[nthRep] = nClusters;
csd->MaxClusterSize[nthRep] = csize;
csd->MaxSig[nthRep] = sigmax;
csd->MaxStat[nthRep] = zmax;
} // Sign
} // Thresh
} // FWHM
printf("\n");
if(fpLog) fprintf(fpLog,"\n");
if(SaveEachIter || fio_FileExistsReadable(SaveFile)) SaveOutput();
if(fio_FileExistsReadable(StopFile)) {
printf("Found stop file %s\n",StopFile);
goto finish;
}
} // Simulation Repetition
finish:
SaveOutput();
msecTime = TimerStop(&mytimer) ;
printf("Total Sim Time %g min (%g per rep)\n",
msecTime/(1000*60.0),(msecTime/(1000*60.0))/nthRep);
if(fpLog) fprintf(fpLog,"Total Sim Time %g min (%g per rep)\n",
msecTime/(1000*60.0),(msecTime/(1000*60.0))/nthRep);
if(DoneFile){
fp = fopen(DoneFile,"w");
fprintf(fp,"%g\n",msecTime/(1000*60.0));
fclose(fp);
}
printf("mri_mcsim done\n");
if(fpLog){
fprintf(fpLog,"mri_mcsim done\n");
fclose(fpLog);
}
exit(0);
}
/***-------------------------------------------------------****/
int main(int argc, char *argv[])
{
int nargs, index, ac, nvolumes;
char **av ;
MRI *mri_or = NULL, *mri ;
/* rkt: check for and handle version tag */
nargs = handle_version_option (argc, argv, vcid, "$Name: $");
if (nargs && argc - nargs == 1)
exit (0);
Progname = argv[0] ;
argc -= nargs;
ac = argc ;
av = argv ;
for ( ; argc > 1 && ISOPTION(*argv[1]) ; argc--, argv++)
{
nargs = get_option(argc, argv) ;
argc -= nargs ;
argv += nargs ;
}
nvolumes = argc-2 ;
if (nvolumes <= 0)
usage_exit() ;
printf("processing %d input files\n", nvolumes) ;
ErrorInit(NULL, NULL, NULL) ;
DiagInit(NULL, NULL, NULL) ;
for (index = 0 ; index < nvolumes ; index++)
{
char *fname = argv[index+1] ;
printf("processing input volume %d of %d: %s\n",
index+1, nvolumes, fname) ;
mri = MRIread(fname) ;
if (index == 0){
mri_or = MRIcopy(mri, NULL) ;
// if nvolumes == 1 binarize the volume! LZ: MRIbinarize(MRI *mri_src, MRI *mri_dst, float threshold, float low_val,float hi_val)
if (nvolumes == 1) {
if(use_orig_value)
MRIorVal(mri, mri_or, mri_or, 0) ;
else
MRIor(mri, mri_or, mri_or, 0) ;
}
}
else {
if(use_orig_value)
MRIorVal(mri, mri_or, mri_or, 0) ;
else
MRIor(mri, mri_or, mri_or, 0) ;
}
MRIfree(&mri) ;
}
printf("writing output to %s\n", argv[argc-1]) ;
MRIwrite(mri_or, argv[argc-1]) ;
exit(0);
} /* end main() */
/***-------------------------------------------------------****/
int main(int argc, char *argv[])
{
int nargs, ac, nvolumes;
char **av ;
MRI *outmri0 = NULL, *outmri1 = NULL, *outmri2 = NULL, *outmri3 = NULL, *outmri4 = NULL, *segmri ;
/* rkt: check for and handle version tag */
nargs = handle_version_option (argc, argv, vcid, "$Name: $");
if (nargs && argc - nargs == 1)
exit (0);
Progname = argv[0] ;
argc -= nargs;
ac = argc ;
av = argv ;
for ( ; argc > 1 && ISOPTION(*argv[1]) ; argc--, argv++)
{
nargs = get_option(argc, argv) ;
argc -= nargs ;
argv += nargs ;
}
nvolumes = argc-1 ;
printf("processing %d input files\n", nvolumes) ;
if (nvolumes != 2)
usage_exit() ;
printf("processing %d input files\n", nvolumes) ;
ErrorInit(NULL, NULL, NULL) ;
DiagInit(NULL, NULL, NULL) ;
char *fname = argv[1] ;
printf("processing segmentation input volume %s\n", fname) ;
segmri = MRIread(fname) ;
//int width = segmri->width ;
//int height = segmri->height ;
//int depth = segmri->depth ;
char *outputfname = argv[2] ;
printf("output fname %s\n", outputfname) ;
// GM/WM
outmri0 = MRIcopy(segmri, NULL) ;
// MRIwrite(outmri0, "/tmp/segmri.mgz") ;
correct_gmwm_boundaries(segmri, outmri0);
// MRIwrite(outmri0, "/tmp/outmri0.mgz") ;
// putamen / pallidum
outmri1 = MRIcopy(outmri0, NULL) ;
correct_putamen_pallidum_boundaries(outmri0, outmri1);
// MRIwrite(outmri1, "/tmp/outmri1.mgz") ;
// GM / WM
outmri2 = MRIcopy(outmri1, NULL) ;
correct_gmwm_boundaries_2(outmri1, outmri2);
// MRIwrite(outmri2, "/tmp/outmri2.mgz") ;
// find largest connected components and close holes
outmri3 = MRIcopy(segmri, NULL) ;
MRIvalueFill(outmri3, 0);
correct_largestCC_and_fill_holes(outmri2, outmri3);
// MRIwrite(outmri3, "/tmp/outmri3.mgz") ;
// fill leftover voxels in origiinal mask
outmri4 = MRIcopy(outmri3, NULL) ;
fill_leftover_voxels(segmri, outmri3, outmri4);
// MRIwrite(outmri4, "/tmp/outmri4.mgz") ;
//
outmri0 = MRIcopy(outmri4, NULL) ;
correct_gmwm_boundaries(outmri4, outmri0);
// MRIwrite(outmri0, "/tmp/redone-outmri0.mgz") ;
outmri1 = MRIcopy(outmri0, NULL) ;
correct_putamen_pallidum_boundaries(outmri0, outmri1);
// MRIwrite(outmri1, "/tmp/redone-outmri1.mgz") ;
outmri2 = MRIcopy(outmri1, NULL) ;
correct_gmwm_boundaries_2(outmri1, outmri2);
// MRIwrite(outmri2, "/tmp/redone-outmri2.mgz") ;
//
printf("writing output to %s\n", outputfname) ;
MRIwrite(outmri2, outputfname) ;
MRIfree(&segmri) ;
MRIfree(&outmri0);
MRIfree(&outmri1);
MRIfree(&outmri2);
MRIfree(&outmri3);
MRIfree(&outmri4);
exit(0);
} /* end main() */
int
main(int argc, char *argv[])
{
char **av, *in_vol, *out_vol;
int ac, nargs;
MRI *mri_in, *mri_out, *mri_tmp ;
LTA *lta = 0;
MATRIX *i_to_r_src = 0; /* src geometry of the input LTA */
MATRIX *V_to_V = 0; /* Final voxel-to-voxel transform */
MATRIX *r_to_i_dst = 0; /* dst geometry of the input LTA */
MATRIX *m_tmp = 0;
MATRIX *i_to_r_reg = 0; /* i_to_r of the volume after registration */
MATRIX *r_to_i_out = 0; /* r_to_i of the final output volume */
VOL_GEOM vgm_in;
int x, y, z;
double maxV, minV, value;
// MATRIX *i_to_r, *r_to_i;
/* rkt: check for and handle version tag */
nargs = handle_version_option (argc, argv, "$Id: mri_transform_to_COR.c,v 1.8 2011/03/02 00:04:55 nicks Exp $", "$Name: stable5 $");
if (nargs && argc - nargs == 1)
usage_exit (0);
argc -= nargs;
Progname = argv[0] ;
ErrorInit(NULL, NULL, NULL) ;
DiagInit(NULL, NULL, NULL) ;
ac = argc ;
av = argv ;
for ( ; argc > 1 && ISOPTION(*argv[1]) ; argc--, argv++)
{
nargs = get_option(argc, argv) ;
argc -= nargs ;
argv += nargs ;
}
if (argc < 3)
usage_exit(0) ;
in_vol = argv[1] ;
out_vol = argv[2] ;
printf("reading volume from %s...\n", in_vol) ;
mri_in = MRIread(in_vol) ;
if (!mri_in)
ErrorExit(ERROR_NOFILE, "%s: could not read MRI volume %s", Progname,
in_vol) ;
/* Convert mri_in to float type */
/* double would be more accurate */
if (mri_in->type != MRI_FLOAT)
{
printf("Input volume type is %d\n", mri_in->type);
printf("Change input volume to float type for convenience and accuracy");
mri_tmp = MRIchangeType(mri_in, MRI_FLOAT, 0, 1.0, 1);
MRIfree(&mri_in);
mri_in = mri_tmp; //swap
}
/* Get input volume geometry, which is needed to compute i_to_r
* and r_to_i of input volume. Note that i_to_r and r_to_i assumed
* a certain prespecified c_r, c_a, c_s
*/
getVolGeom(mri_in, &vgm_in);
maxV = -10000.0;
minV = 10000.0;
for (z=0; z < mri_in->depth; z++)
for (y=0; y< mri_in->height; y++)
for (x=0; x < mri_in->width; x++)
{
if (MRIFvox(mri_in, x, y, z) > maxV )
maxV = MRIFvox(mri_in, x, y,z) ;
if (MRIFvox(mri_in, x, y, z) < minV )
minV = MRIFvox(mri_in, x, y,z) ;
}
printf("Input volume has max = %g, min =%g\n", maxV, minV);
printf("Scale input volume by %g \n", scale);
maxV = -10000.0;
minV = 10000.0;
for (z=0; z < mri_in->depth; z++)
for (y=0; y< mri_in->height; y++)
for (x=0; x < mri_in->width; x++)
{
MRIFvox(mri_in, x, y, z) *= scale;
if (MRIFvox(mri_in, x, y, z) > maxV )
maxV = MRIFvox(mri_in, x, y,z) ;
if (MRIFvox(mri_in, x, y, z) < minV )
minV = MRIFvox(mri_in, x, y,z) ;
}
printf("Input volume after scaling has max = %g, min =%g\n", maxV, minV);
/* Try to compute the Voxel_to_Voxel transform from the input volume
* and the registration target/reference volume!
* If no registration is involved, vox_to_vox is simply identity
*/
/* Things become more complicated when allowing inverse transform */
if (transform_flag)
{
int transform_type;
printf("INFO: Applying transformation from file %s...\n",
transform_fname);
transform_type = TransformFileNameType(transform_fname);
/* Read in LTA transform file name */
if (transform_type == MNI_TRANSFORM_TYPE ||
transform_type == TRANSFORM_ARRAY_TYPE ||
transform_type == REGISTER_DAT ||
transform_type == FSLREG_TYPE
)
{
printf("Reading transform ...\n");
lta = LTAreadEx(transform_fname) ;
if (!lta)
ErrorExit(ERROR_NOFILE, "%s: could not read transform file %s",
Progname, transform_fname) ;
if (transform_type == FSLREG_TYPE)
{
if (lta_src == 0 || lta_dst == 0)
{
fprintf(stderr, "ERROR: fslmat does not have information on the src and dst volumes\n");
fprintf(stderr, "ERROR: you must give options '-src' and '-dst' to specify the src and dst volume infos for the registration\n");
}
LTAmodifySrcDstGeom(lta, lta_src, lta_dst); // add src and dst information
//The following is necessary to interpret FSLMAT correctly!!!
LTAchangeType(lta, LINEAR_VOX_TO_VOX);
}
if (lta->xforms[0].src.valid == 0)
{
if (lta_src == 0)
{
fprintf(stderr, "The transform does not have the valid src volume info.\n");
fprintf(stderr, "Either you give src volume info by option -src or\n");
fprintf(stderr, "make the transform to have the valid src info.\n");
ErrorExit(ERROR_BAD_PARM, "Bailing out...\n");
}
else
{
LTAmodifySrcDstGeom(lta, lta_src, NULL); // add src information
}
}
if (lta->xforms[0].dst.valid == 0)
{
if (lta_dst == 0)
{
fprintf(stderr, "The transform does not have the valid dst volume info.\n");
fprintf(stderr, "Either you give src volume info by option -dst or\n");
fprintf(stderr, "make the transform to have the valid dst info.\n");
fprintf(stderr, "If the dst was average_305, then you can set\n");
fprintf(stderr, "environmental variable USE_AVERAGE305 true\n");
fprintf(stderr, "instead.\n");
ErrorExit(ERROR_BAD_PARM, "Bailing out...\n");
}
else
{
LTAmodifySrcDstGeom(lta, NULL, lta_dst); // add dst information
}
}
// The following procedure aims to apply an LTA computed from COR format to a volume in non-COR format, or vice versa, as long as they share the same RAS
// first change to LINEAR RAS_TO_RAS using old info
if (lta->type != LINEAR_RAS_TO_RAS)
{
LTAchangeType(lta, LINEAR_RAS_TO_RAS);
}
// now possiblly reset the src and dst
if (lta_src != NULL)
{
//always trust the user
LTAmodifySrcDstGeom(lta, lta_src, NULL);
}
if (lta_dst != NULL)
{
//always trust the user
LTAmodifySrcDstGeom(lta, NULL, lta_dst);
}
if (lta->type == LINEAR_RAS_TO_RAS)
{
/* Convert it to VOX_TO_VOX */
/* VOXELsrc_to_VOXELdst = R2Vdst*R2Rlta*V2Rsrc */
/* Note whether the input should be identical to src or dst here depends
* on whether the LTA here is the direct or inverse transform
*/
i_to_r_src = vg_i_to_r(<a->xforms[0].src);
r_to_i_dst = vg_r_to_i(<a->xforms[0].dst);
if (!r_to_i_dst || !i_to_r_src)
ErrorExit(ERROR_BADFILE, "%s: failed to extract volume geometries from input LTA file",Progname);
m_tmp = MatrixMultiply(lta->xforms[0].m_L, i_to_r_src, NULL);
V_to_V = MatrixMultiply(r_to_i_dst, m_tmp, NULL);
MatrixFree(&m_tmp);
MatrixFree(&i_to_r_src);
MatrixFree(&r_to_i_dst);
}
}
else
{
fprintf(stderr, "unknown transform type in file %s\n",
transform_fname);
exit(1);
}
if (invert_flag)
{
/* Geometry of input volume should match that of the dst of the LTA */
if (MYvg_isEqual(<a->xforms[0].dst, &vgm_in) == 0)
{
ErrorExit(ERROR_BADFILE, "%s: dst volume of lta doesn't match that of input volume",Progname);
}
i_to_r_reg = vg_i_to_r(<a->xforms[0].src);
if (!i_to_r_reg)
ErrorExit(ERROR_BADFILE, "%s: failed to extract i_to_r of registered volume from LTA",Progname);
m_tmp = MatrixInverse(V_to_V, NULL);
if (!m_tmp)
ErrorExit(ERROR_BADPARM, "%s: transform is singular!", Progname);
MatrixFree(&V_to_V);
V_to_V = m_tmp;
}
else
{
/* Geometry of input volume should match that of the src of the LTA */
if (MYvg_isEqual(<a->xforms[0].src, &vgm_in) == 0)
{
ErrorExit(ERROR_BADFILE, "%s: src volume of lta doesn't match that of input volume",Progname);
}
i_to_r_reg = vg_i_to_r(<a->xforms[0].dst);
if (!i_to_r_reg)
ErrorExit(ERROR_BADFILE, "%s: failed to extract i_to_r of registered volume from LTA",Progname);
}
}
else
{
/* No registration transform need be applied */
V_to_V = MatrixIdentity(4, NULL);
i_to_r_reg = extract_i_to_r(mri_in);
if (!i_to_r_reg)
ErrorExit(ERROR_BADFILE, "%s: failed to extract i_to_r from input volume",Progname);
}
/* Now need to find the vox-to-vox transformation between registered volume
* (or input volume itself if no registration involved) and the output
* volume, either in COR format or as the out-like volume
*/
/* Given a volume with a certain i_to_r, we need to compute the necessary
* vox-to-voxel transform to change its i_to_r to like another volume.
* The vox-to-vox is equal to R2V(r_to_i)_likevol*i_to_r_current_vol.
*/
if (out_like_fname)
{
mri_tmp = MRIread(out_like_fname) ;
if (!mri_tmp)
ErrorExit(ERROR_NOFILE, "%s: could not read template volume from %s",out_like_fname) ;
/* out_type = mri_tmp->type; */
/* specify the out-type to float initially so as not to lose accuracy
* during reslicing, will change type to correct type later.
*/
mri_out = MRIalloc(mri_tmp->width, mri_tmp->height, mri_tmp->depth, MRI_FLOAT) ;
MRIcopyHeader(mri_tmp, mri_out) ;
MRIfree(&mri_tmp);
}
else /* assume output is in COR format */
{
mri_out = MRIalloc(256, 256, 256, MRI_FLOAT) ;
/* out_type = MRI_UCHAR; */
/* Who says MRIlinearTransformInterp will change the header??
* I don't think so!
*/
//E/ set xyzc_ras to coronal ones.. - these'll get zorched
//by MRIlinearTransformInterp() - copy again later - is there
//any use in having them here now? yes, so we can pass mri_out
//to the ras2vox fns.
mri_out->imnr0 = 1; /* what's this? */
mri_out->imnr1 = 256; /* what's this? */
mri_out->thick = 1.0;
mri_out->ps = 1.0; /* what's this? */
mri_out->xsize = mri_out->ysize = mri_out->zsize = 1.0;
mri_out->xstart = mri_out->ystart = mri_out->zstart = -128.0;
mri_out->xend = mri_out->yend = mri_out->zend = 128.0;
mri_out->x_r =-1;
mri_out->y_r = 0;
mri_out->z_r = 0;
mri_out->x_a = 0;
mri_out->y_a = 0;
mri_out->z_a = 1;
mri_out->x_s = 0;
mri_out->y_s =-1;
mri_out->z_s = 0;
/* In this case, the RAS itself is not fully determined, i.e., c_ras.
* It's quite arbitrary, different values just change the final
* sitting of the volume inside the RAS system.
*/
/* NO! The C_RAS has to be set correctly, depending which target
* volume the previous Vox_to_Vox transformation assumes!
* When a registration is involved, the target volume is either
* the src of LTA (direct) or the dst (inverse transform). When
* just change format, the target volume is the input itself!!
*/
if (transform_flag)
{
if (invert_flag)
{
mri_out->c_r = lta->xforms[0].src.c_r;
mri_out->c_a = lta->xforms[0].src.c_a;
mri_out->c_s = lta->xforms[0].src.c_s;
}
else
{
mri_out->c_r = lta->xforms[0].dst.c_r;
mri_out->c_a = lta->xforms[0].dst.c_a;
mri_out->c_s = lta->xforms[0].dst.c_s;
}
}
else
{
mri_out->c_r = mri_in->c_r;
mri_out->c_a = mri_in->c_a;
mri_out->c_s = mri_in->c_s;
}
mri_out->ras_good_flag=1; /* What does this flag mean ? */
/* since output is just transformed input */
MRIcopyPulseParameters(mri_in, mri_out) ;
}
/* Compute the final input-to-output VOX_to_VOX transformation matrix */
r_to_i_out = extract_r_to_i(mri_out);
m_tmp = MatrixMultiply(r_to_i_out, i_to_r_reg, NULL);
V_to_V = MatrixMultiply(m_tmp, V_to_V, V_to_V);
MatrixFree(&m_tmp);
printf("InterpMethod = %d\n", InterpMethod);
/* Modify the MyMRIlinearTr... if I want to implement my cubic-B-spline
* interpolation method. Otherwise, unnecessary
*/
/* mri_out = MyMRIlinearTransformInterp(mri_in, mri_out, V_to_V, InterpMethod); */
if (InterpMethod == SAMPLE_BSPLINE)
mri_out = MRIlinearTransformInterpBSpline(mri_in, mri_out, V_to_V,
SplineDegree);
else
mri_out = MRIlinearTransformInterp(mri_in, mri_out, V_to_V, InterpMethod);
maxV = -10000.0;
minV = 10000.0;
for (z=0; z < mri_out->depth; z++)
for (y=0; y< mri_out->height; y++)
for (x=0; x < mri_out->width; x++)
{
if (MRIFvox(mri_out, x, y, z) > maxV )
maxV = MRIFvox(mri_out, x, y,z) ;
if (MRIFvox(mri_out, x, y, z) < minV )
minV = MRIFvox(mri_out, x, y,z) ;
}
if (autoscale)
{
noscale = 1;
/* compute histogram of output volume */
HISTOGRAM *h, *hsmooth ;
float fmin, fmax, val, peak, smooth_peak;
int i, nbins, bin;
fmin = minV;
fmax = maxV;
if (fmin < 0) fmin = 0;
nbins = 256 ;
h = HISTOalloc(nbins) ;
hsmooth = HISTOcopy(h, NULL) ;
HISTOclear(h, h) ;
h->bin_size = (fmax-fmin)/255.0 ;
for (i = 0 ; i < nbins ; i++)
h->bins[i] = (i+1)*h->bin_size ;
for (z=0; z < mri_out->depth; z++)
for (y=0; y< mri_out->height; y++)
for (x=0; x < mri_out->width; x++)
{
val = MRIFvox(mri_out, x, y, z);
if (val <= 0) continue;
bin = nint((val - fmin)/h->bin_size);
if (bin >= h->nbins)
bin = h->nbins-1;
else if (bin < 0)
bin = 0;
h->counts[bin] += 1.0;
}
HISTOfillHoles(h) ;
HISTOsmooth(h, hsmooth, 5) ;
peak =
hsmooth->bins[HISTOfindHighestPeakInRegion(h, 1, h->nbins)] ;
// smooth_peak =
// hsmooth->bins[HISTOfindHighestPeakInRegion(hsmooth, 1, hsmooth->nbins)] ;
smooth_peak =
hsmooth->bins[HISTOfindLastPeak(hsmooth, 5, 0.8)] ;
/*
bin = nint((smooth_peak - fmin)/hsmooth->bin_size) ;
printf("Highest peak has count = %d\n", (int)hsmooth->counts[bin]);
bin = nint((420 - fmin)/hsmooth->bin_size) ;
printf("bin at 420 has count = %d\n", (int)hsmooth->counts[bin]);
*/
scale = 110.0/smooth_peak;
printf("peak of output volume is %g, smooth-peak is %g, multiply by %g to scale it to 110\n", peak, smooth_peak, scale);
for (z=0; z < mri_out->depth; z++)
for (y=0; y< mri_out->height; y++)
for (x=0; x < mri_out->width; x++)
{
val = MRIFvox(mri_out, x, y, z);
MRIFvox(mri_out, x, y, z) = val*scale;
}
}
printf("Output volume (before type-conversion) has max = %g, min =%g\n", maxV, minV);
/* Finally change type to desired */
if (mri_out->type != out_type)
{
printf("Change output volume to type %d\n", out_type);
/* I need to modify the MIRchangeType function to make sure
* it does roundoff instead of simple truncation!
*/
/* Note if the last flag is set to 1, then it won't do scaling
and small float numbers will become zero after convert to
BYTE
*/
if (out_type == 0 && noscale == 1)
{
//convert data to UCHAR
mri_tmp = MRIalloc(mri_out->width, mri_out->height, mri_out->depth, out_type) ;
MRIcopyHeader(mri_out, mri_tmp);
for (z=0; z < mri_out->depth; z++)
for (y=0; y< mri_out->height; y++)
for (x=0; x < mri_out->width; x++)
{
value = floor(MRIgetVoxVal(mri_out, x, y, z, 0) + 0.5);
if (value < 0 ) value = 0;
if (value > 255) value = 255;
MRIvox(mri_tmp,x,y,z) = (unsigned char)value;
}
}
else
mri_tmp = MRIchangeType(mri_out, out_type, thred_low, thred_high, noscale);
MRIfree(&mri_out);
mri_out = mri_tmp; //swap
}
MRIwrite(mri_out, out_vol) ;
MRIfree(&mri_in);
MRIfree(&mri_out);
if (lta_src)
MRIfree(<a_src);
if (lta_dst)
MRIfree(<a_dst);
MatrixFree(&V_to_V);
if (!r_to_i_out)
MatrixFree(&r_to_i_out);
if (!i_to_r_reg)
MatrixFree(&i_to_r_reg);
return(0) ; /* for ansi */
}