static int convert_single_label_to_path (char* fname, char* ofname) {
LABEL* label = NULL;
int label_vno;
int num_paths;
PATH** paths = NULL;
int err;
/* Read the label file. */
label = LabelRead (NULL, fname);
if (NULL == label) {
ErrorReturn (ERROR_BADFILE,
(ERROR_BADFILE, "Couldn't read %s", fname));
}
/* Count the number of sentinels, -99999 vnos in the label; we only
want one path, so this is just to check if this is a
multiple-path label file. */
num_paths = 0;
for (label_vno = 0; label_vno < label->n_points; label_vno++) {
if (-99999 == label->lv[label_vno].vno)
num_paths++;
}
/* Make sure we only got one paths. */
if (num_paths > 1) {
printf ("WARNING: Found multiple paths in label file.\n"
"Maybe you didn't mean to use the single option?\n"
"Converting it to a single path.\n");
}
/* Allocate path objects. */
paths = (PATH**) calloc (1, sizeof(PATH*));
if (NULL == paths) {
ErrorReturn (ERROR_NO_MEMORY,
(ERROR_NO_MEMORY, "Couldn't allocate %d paths", 1));
}
err = PathCreateFromLabel (label, &paths[0]);
if (ERROR_NONE != err) {
free (paths);
return err;
}
/* Write the path file. */
err = PathWriteMany (ofname, 1, paths);
if (0 != err) {
ErrorReturn (ERROR_BADFILE,
(ERROR_BADFILE, "Couldn't write to %s", ofname));
}
PathFree (&paths[0]);
free (paths);
return (ERROR_NONE);
}
int
main(int argc, char *argv[])
{
char **av, fname[STRLEN], *cp ;
int ac, nargs ;
char *subject, *out_fname, *hemi, *ohemi ;
int msec, minutes, seconds ;
struct timeb start ;
MRI *mri, *mri_features, *mri_ribbon, *mri_aseg, *mri_aparc ;
MRI_SURFACE *mris, *mris_contra ;
LABEL *cortex ;
/* rkt: check for and handle version tag */
nargs = handle_version_option (argc, argv, "$Id: mri_extract_fcd_features.c,v 1.1 2016/06/15 17:51:09 fischl Exp $", "$Name: $");
if (nargs && argc - nargs == 1)
exit (0);
argc -= nargs;
Progname = argv[0] ;
ErrorInit(NULL, NULL, NULL) ;
DiagInit(NULL, NULL, NULL) ;
TimerStart(&start) ;
ac = argc ;
av = argv ;
for ( ; argc > 1 && ISOPTION(*argv[1]) ; argc--, argv++) {
nargs = get_option(argc, argv) ;
argc -= nargs ;
argv += nargs ;
}
if (argc < 4)
usage_exit(1) ;
subject = argv[1] ;
hemi = argv[2] ;
if (strcmp(hemi, "lh") == 0)
ohemi = "rh" ;
else
ohemi = "lh" ;
out_fname = argv[3] ;
printf("reading data for subject %s and writing output to %s\n", subject, out_fname) ;
if (!strlen(sdir))
{
cp = getenv("SUBJECTS_DIR") ;
if (!cp)
ErrorExit(ERROR_BADPARM,
"%s: SUBJECTS_DIR not defined in environment.\n", Progname) ;
strcpy(sdir, cp) ;
}
sprintf(fname, "%s/%s/surf/%s.%s", sdir, subject, hemi, white_name) ;
printf("reading %s\n", fname) ;
mris = MRISread(fname) ;
if (mris == NULL)
ErrorExit(ERROR_NOFILE, "%s: could not read surface from %s\n", Progname, fname) ;
MRISsaveVertexPositions(mris, WHITE_VERTICES) ;
sprintf(fname, "%s/%s/surf/%s.%s", sdir, subject, ohemi, white_name) ;
printf("reading %s\n", fname) ;
mris_contra = MRISread(fname) ;
if (mris_contra == NULL)
ErrorExit(ERROR_NOFILE, "%s: could not read surface from %s\n", Progname, fname) ;
MRISsaveVertexPositions(mris_contra, WHITE_VERTICES) ;
sprintf(fname, "%s/%s/mri/%s", sdir, subject, ribbon_name) ;
printf("reading %s\n", fname) ;
mri_ribbon = MRIread(fname) ;
if (mri_ribbon == NULL)
ErrorExit(ERROR_NOFILE, "%s: could not read ribbon from %s\n", Progname, fname) ;
sprintf(fname, "%s/%s/mri/%s", sdir, subject, aparc_name) ;
printf("reading %s\n", fname) ;
mri_aparc = MRIread(fname) ;
if (mri_aparc == NULL)
ErrorExit(ERROR_NOFILE, "%s: could not read ribbon from %s\n", Progname, fname) ;
sprintf(fname, "%s/%s/mri/%s", sdir, subject, aseg_name) ;
printf("reading %s\n", fname) ;
mri_aseg = MRIread(fname) ;
if (mri_aseg == NULL)
ErrorExit(ERROR_NOFILE, "%s: could not read aseg from %s\n", Progname, fname) ;
sprintf(fname, "%s/%s/surf/%s.%s", sdir, subject, hemi, pial_name) ;
if (MRISreadPialCoordinates(mris, fname) != NO_ERROR)
ErrorExit(ERROR_NOFILE, "%s: could not read pial coordinates from %s\n", Progname, fname) ;
sprintf(fname, "%s/%s/surf/%s.%s", sdir, subject, hemi, sphere_name) ;
if (MRISreadCanonicalCoordinates(mris, fname) != NO_ERROR)
ErrorExit(ERROR_NOFILE, "%s: could not read left/right spherical coordinates from %s\n", Progname, fname) ;
sprintf(fname, "%s/%s/surf/%s.%s", sdir, subject, ohemi, pial_name) ;
if (MRISreadPialCoordinates(mris_contra, fname) != NO_ERROR)
ErrorExit(ERROR_NOFILE, "%s: could not read pial coordinates from %s\n", Progname, fname) ;
sprintf(fname, "%s/%s/label/%s.%s", sdir, subject, hemi, cortex_label) ;
cortex = LabelRead(NULL, fname) ;
if (cortex == NULL)
ErrorExit(ERROR_NOFILE, "%s: could not read cortical label from %s\n", Progname, fname) ;
LabelRipRestOfSurface(cortex, mris) ;
LabelFree(&cortex) ;
sprintf(fname, "%s/%s/surf/%s.%s", sdir, subject, ohemi, sphere_name) ;
if (MRISreadCanonicalCoordinates(mris_contra, fname) != NO_ERROR)
ErrorExit(ERROR_NOFILE, "%s: could not read left/right spherical coordinates from %s\n", Progname, fname) ;
sprintf(fname, "%s/%s/mri/%s", sdir, subject, vol_name) ;
printf("reading %s\n", fname) ;
mri = MRIread(fname) ;
if (mri == NULL)
ErrorExit(ERROR_NOFILE, "%s: could not read volume from %s\n", Progname, fname) ;
if (0)
mri_features = MRIcomputeSurfaceDistanceProbabilities(mris, mri_ribbon, mri, mri_aseg) ;
else
{
MRI *mri_ohemi_features, *mri_ohemi_mapped_to_hemi_features ;
mri_features = MRIcomputeSurfaceDistanceIntensities(mris, mri_ribbon, mri_aparc, mri, mri_aseg, whalf) ;
mri_ohemi_features = MRIcomputeSurfaceDistanceIntensities(mris_contra, mri_ribbon, mri_aparc, mri, mri_aseg, whalf) ;
mri_ohemi_mapped_to_hemi_features = MRISmapToSurface(mris_contra, mris, mri_ohemi_features, NULL) ; // map contra feature to this surface
// MRIwrite(mri_ohemi_mapped_to_hemi_features, "test.mgz") ;
MRIsubtract(mri_features, mri_ohemi_mapped_to_hemi_features, mri_features) ;
}
if (navgs > 0)
{
MRI *mri_tmp ;
mri_tmp = MRISsmoothMRI(mris, mri_features, navgs, NULL, NULL);
MRIfree(&mri_features) ;
mri_features = mri_tmp ;
}
printf("writing output to %s\n", out_fname) ;
if (Gdiag_no >= 0)
printf("feature(%d) = %f\n", Gdiag_no, MRIgetVoxVal(mri_features, Gdiag_no, 0, 0, 0)) ;
MRIwrite(mri_features, out_fname) ;
msec = TimerStop(&start) ;
seconds = nint((float)msec/1000.0f) ;
minutes = seconds / 60 ;
seconds = seconds % 60 ;
fprintf(stderr, "feature extraction took %d minutes and %d seconds.\n", minutes, seconds) ;
exit(0) ;
return(0) ;
}
int
main(int argc, char *argv[]) {
char **av, *cp, fname[STRLEN], *subject, *out_fname ;
int ac, nargs, msec, minutes, n, seconds, nsubjects, i, sno, nfeatures, correct ;
struct timeb start ;
LABEL *cortex_label, *training_label ;
RANDOM_FOREST *rf ;
double **training_data ;
int *training_classes, ntraining ;
/* rkt: check for and handle version tag */
nargs = handle_version_option (argc, argv, "$Id: mris_rf_train.c,v 1.1 2012/06/07 12:09:47 fischl Exp $", "$Name: $");
if (nargs && argc - nargs == 1)
exit (0);
argc -= nargs;
Progname = argv[0] ;
ErrorInit(NULL, NULL, NULL) ; setRandomSeed(0L);
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) ;
if (strlen(sdir) == 0) {
cp = getenv("SUBJECTS_DIR") ;
if (!cp)
ErrorExit(ERROR_BADPARM, "%s: SUBJECTS_DIR not defined in env or cmd line",Progname) ;
strcpy(sdir, cp) ;
}
nsubjects = argc-(ARGC_OFFSET+1) ;
printf("training random forest classifier using %d subjects\n", nsubjects) ;
for (n = ARGC_OFFSET ; n < argc-1 ; n++)
{
subject = argv[n] ;
sno = n-ARGC_OFFSET ;
printf("processing subject %s: %d of %d\n", subject, sno+1, nsubjects) ;
sprintf(fname, "%s/%s/label/lh.%s.label", sdir, subject, label_name) ;
if (FileExists(fname) == 0)
{
sprintf(fname, "%s/%s/label/rh.%s.label", sdir, subject, label_name) ;
if (FileExists(fname) == 0)
ErrorExit(ERROR_NOFILE, "%s: subject %s has no training label for either hemisphere", Progname, subject) ;
hemi = "rh" ;
}
else
hemi = "lh" ;
training_label = LabelRead(NULL, fname) ;
if (training_label == NULL)
ErrorExit(ERROR_NOFILE, "%s: could not read training label %s\n", Progname, fname) ;
sprintf(fname, "%s/%s/surf/%s.%s", sdir, subject, hemi, surf_name) ;
mris[sno] = MRISread(fname) ;
if (!mris[sno])
ErrorExit(ERROR_NOFILE, "%s: could not read surface from %s",Progname, fname) ;
MRIScomputeMetricProperties(mris[sno]) ;
if (nbhd_size > mris[sno]->nsize)
MRISsetNeighborhoodSize(mris[sno], nbhd_size) ;
sprintf(fname, "%s/%s/label/%s.%s", sdir, subject, hemi, cortex_label_name) ;
cortex_label = LabelRead(NULL, fname) ;
if (cortex_label == NULL)
ErrorExit(ERROR_NOFILE, "%s: could not read cortex label %s\n", Progname, fname) ;
LabelRipRestOfSurface(cortex_label, mris[sno]) ;
MRISclearMarks(mris[sno]) ;
LabelFillUnassignedVertices(mris[sno], training_label, CURRENT_VERTICES);
LabelDilate(training_label, mris[sno], ndilates) ;
LabelMark(training_label, mris[sno]) ;
LabelFree(&training_label) ;
for (i = 0 ; i < noverlays ; i++)
{
sprintf(fname, "%s/%s/surf/%s.%s", sdir, subject, hemi, overlay_names[i]) ;
mri_overlays[sno][i] = MRIread(fname) ;
if (mri_overlays[sno][i] == NULL)
ErrorExit(ERROR_NOFILE, "%s: could not read overlay %s (%d)\n", Progname, fname, i) ;
}
LabelFree(&cortex_label) ;
}
nfeatures = noverlays*(nbhd_size+1) ;
rf = RFalloc(ntrees, nfeatures, 2, max_depth, class_names, 100) ;
rf->feature_names = (char **)calloc(nfeatures, sizeof(char *)) ;
for (i = 0 ; i < noverlays ; i++)
{
rf->feature_names[i] = (char *)calloc(strlen(overlay_names[i])+1, sizeof(char)) ;
strcpy(rf->feature_names[i], overlay_names[i]) ;
}
assemble_training_data_and_free_mris(mris, mri_overlays, nsubjects, noverlays, &training_classes, &training_data, &ntraining) ;
RFtrain(rf, 1.0, training_fraction, training_classes, training_data, ntraining);
correct = RFcomputeOutOfBagCorrect(rf, training_classes, training_data, ntraining);
printf("out of bag accuracy = %2.1f (%d of %d)\n", (float)correct*100.0f/ntraining, correct, ntraining) ;
RFevaluateFeatures(rf, stdout) ;
out_fname = argv[argc-1] ;
printf("writing output to %s\n", out_fname) ;
RFwrite(rf, out_fname) ;
msec = TimerStop(&start) ;
seconds = nint((float)msec/1000.0f) ;
minutes = seconds / 60 ;
seconds = seconds % 60 ;
printf("random forest training took %d minutes and %d seconds.\n", minutes, seconds) ;
exit(0) ;
return(0) ;
}
int
main(int argc, char *argv[]) {
char **av, *surf_fname, *profile_fname, *seg_fname ;
int ac, nargs ;
MRI_SURFACE *mris, *mris_ico = NULL ;
// LABEL *label = NULL ;
MRI *mri_profiles ;
CLUSTER *ct ;
setRandomSeed(10L) ;
/* rkt: check for and handle version tag */
nargs = handle_version_option (argc, argv, "$Id: mris_cluster_profiles.c,v 1.4 2011/03/02 00:04:34 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() ;
profile_fname = argv[1] ;
surf_fname = argv[2] ;
seg_fname = argv[3] ;
mris = MRISread(surf_fname) ;
if (!mris)
ErrorExit(ERROR_NOFILE, "%s: could not read surface file %s",
Progname, surf_fname) ;
MRISsetNeighborhoodSize(mris, 2) ;
if (MRISreadAnnotation(mris, "ad_aparc") != NO_ERROR) {
if (MRISreadAnnotation(mris, "aparc") != NO_ERROR)
ErrorExit(ERROR_NOFILE, "%s: could not read annotation file ad_aparc", Progname) ;
}
printf("reading intensity profile volume from %s...\n", profile_fname) ;
mri_profiles = MRIread(profile_fname) ;
if (!mri_profiles)
ErrorExit(ERROR_NOFILE, "%s: could not read intensity volume %s",
Progname, profile_fname) ;
rip_vertices_out_of_fov(mris, mri_profiles) ;
rip_bad_vertices(mris, mri_profiles) ;
MRISclearAnnotations(mris) ;
#if 0
if (nlabels > 0) {
int l ;
char label_name[STRLEN] ;
LABEL *ltotal = NULL ;
for (l = 0 ; l < nlabels ; l++) {
sprintf(label_name, "%s/%s/label/%s.%s.label", sdir, sname, hemi,label_names[l]) ;
label = LabelRead(NULL, label_name) ;
if (!label)
ErrorExit(ERROR_NOFILE, "%s: could not read label file %s...\n", Progname,
label_name) ;
if (num_erode > 0) {
printf("eroding label %d times, npoints went from %d ", num_erode,label->n_points) ;
LabelErode(label, mris, num_erode) ;
printf("to %d ", label->n_points) ;
}
ltotal = LabelCombine(label, ltotal) ;
}
if (nlabels == 0)
ltotal = LabelInFOV(mris, mri, MIN_BORDER_DIST) ;
LabelRipRestOfSurfaceWithThreshold(ltotal, mris, thresh) ;
}
#endif
if (navgs > 0) {
printf("smoothing profiles %d times\n", navgs) ;
MRISsmoothFrames(mris, mri_profiles, navgs) ;
}
if (ico_fname) {
mris_ico = MRISread(ico_fname) ;
if (mris_ico == NULL)
ErrorExit(ERROR_BADPARM, "%s: could not read icosahedron from %s...\n", Progname, ico_fname) ;
}
ct = MRIScluster(mris, mri_profiles, cluster_type, k, start_fname, mris_ico) ;
printf("writing cortical intensity clusters to %s...\n", seg_fname) ;
MRISwriteAnnotation(mris, seg_fname) ;
{
int vno ;
VERTEX *v ;
int c, i ;
char fname[STRLEN], ext[STRLEN] ;
// write average profiles into mri_profiles and write it out
for (vno = 0 ; vno < mris->nvertices ; vno++) {
v = &mris->vertices[vno] ;
if (v->ripflag)
continue ;
c = v->curv ;
if (c < 0)
continue ;
for (i = 0 ; i < mri_profiles->nframes ; i++)
MRIsetVoxVal(mri_profiles, vno, 0, 0, i, VECTOR_ELT(ct[c].v_mean,i+1)) ;
}
FileNameExtension(seg_fname, ext) ;
FileNameRemoveExtension(seg_fname, fname) ;
strcat(fname, "_cluster_avg.mgz") ;
printf("writing average cluster profiles to %s...\n", fname) ;
MRIwrite(mri_profiles, fname) ;
}
MRIfree(&mri_profiles) ;
exit(0) ;
return(0) ; /* for ansi */
}
int
main(int argc, char *argv[]) {
int ac, nargs ;
char **av, *cp, surf_name[100], *hemi, *subject_name, *label_name,
*out_fname ;
MRI_SURFACE *mris ;
LABEL *label ;
/* rkt: check for and handle version tag */
nargs = handle_version_option (argc, argv, "$Id: label2patch.c,v 1.3 2011/03/02 00:04:11 nicks Exp $", "$Name: stable5 $");
if (nargs && argc - nargs == 1)
exit (0);
argc -= nargs;
Progname = argv[0] ;
ErrorInit(NULL, NULL, NULL) ;
DiagInit(NULL, NULL, NULL) ;
/* read in command-line options */
ac = argc ;
av = argv ;
for ( ; argc > 1 && ISOPTION(*argv[1]) ; argc--, argv++) {
nargs = get_option(argc, argv) ;
argc -= nargs ;
argv += nargs ;
}
if (argc < 4)
print_usage() ;
subject_name = argv[1] ;
hemi = argv[2] ;
label_name = argv[3] ;
out_fname = argv[4] ;
if (strlen(subjects_dir) == 0)
{
cp = getenv("SUBJECTS_DIR") ;
if (!cp)
ErrorExit(ERROR_BADPARM, "no subjects directory in environment.\n") ;
strcpy(subjects_dir, cp) ;
}
sprintf(surf_name,"%s/%s/surf/%s.inflated",subjects_dir,subject_name,hemi);
fprintf(stderr, "reading %s...\n", surf_name) ;
mris = MRISread(surf_name) ;
if (!mris)
ErrorExit(ERROR_NOFILE, "%s: could not read surface file %s\n",
surf_name) ;
MRIScomputeMetricProperties(mris) ;
label = LabelRead(subject_name, label_name) ;
if (ndilate)
LabelDilate(label, mris, ndilate) ;
if (nerode)
LabelErode(label, mris, nerode) ;
if (nclose)
{
LabelDilate(label, mris, nclose) ;
LabelErode(label, mris, nclose) ;
}
LabelRipRestOfSurface(label, mris) ;
MRISripFaces(mris) ;
MRISwritePatch(mris, out_fname) ;
if (verbose)
fprintf(stderr, "done.\n") ;
exit(0) ;
return(0) ; /* ansi */
}
int main(int argc, char *argv[]) {
char *inner_mris_fname,*outer_mris_fname,*input_mri_pref,*output_mri_pref;
MRI *mri=0,*mri_src=0;
MRI_SURFACE *inner_mris=0,*outer_mris=0;
int nargs;
LABEL *area = NULL ;
/* rkt: check for and handle version tag */
nargs = handle_version_option
(argc, argv,
"$Id: mri_ribbon.c,v 1.15 2011/03/02 00:04:24 nicks Exp $",
"$Name: $");
if (nargs && argc - nargs == 1)
exit (0);
argc -= nargs;
Progname=argv[0];
if (argc > 1)
while (*argv[1] == '-')
{
int nargs = 0 ;
switch (toupper(argv[1][1]))
{
case 'L':
printf("cropping ribbon to label file %s\n", argv[2]) ;
nargs = 1 ;
area = LabelRead(NULL, argv[2]) ;
if (area == NULL)
ErrorExit(ERROR_NOFILE,
"%s: could not read label file %s\n",
argv[2]) ;
break ;
default:
break ;
}
argc -= (nargs+1) ;
if (argc == 1) break;
argv += (nargs+1) ;
}
/* Set command-line parameters */
if (argc!=5) {
printf("Usage: mri_ribbon [-l fname.label] \\ \n"
" inner_surface_fname \\ \n"
" outer_surface_fname \\ \n"
" input_volume_pref \\ \n"
" output_volume_pref\n");
exit(1);
}
inner_mris_fname=argv[1];
outer_mris_fname=argv[2];
input_mri_pref=argv[3];
output_mri_pref=argv[4];
/* Read surface information from inner surface file */
printf("Reading surface file %s.\n",inner_mris_fname);
inner_mris=MRISread(inner_mris_fname);
if (!inner_mris) {
printf("Could not read surface file %s.\n",inner_mris_fname);
exit(1);
}
/* Read surface information from outer surface file */
printf("Reading surface file %s.\n",outer_mris_fname);
outer_mris=MRISread(outer_mris_fname);
if (!outer_mris) {
printf("Could not read surface file %s.\n",outer_mris_fname);
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) {
printf("Could not read MRI volume directory %s.\n",input_mri_pref);
exit(1);
}
/* Extract ribbon */
printf("Extracting ribbon.\n");
mri=MRISribbon(inner_mris,outer_mris,mri_src,NULL);
if (area)
MRIcropVolumeToLabel(mri, mri, area, inner_mris, outer_mris) ;
/* Save MRI volume to directory */
printf("Writing volume file %s.\n",output_mri_pref);
MRIwrite(mri,output_mri_pref);
MRIfree(&mri);
MRIfree(&mri_src);
MRISfree(&inner_mris);
MRISfree(&outer_mris);
return 0;
}
int
main(int argc, char *argv[]) {
char **av, *label_name, *vol_name, *out_name ;
int ac, nargs ;
int msec, minutes, seconds, i ;
LABEL *area ;
struct timeb start ;
MRI *mri, *mri_seg ;
Real xw, yw, zw, xv, yv, zv, val;
/* rkt: check for and handle version tag */
nargs = handle_version_option (argc, argv, "$Id: mri_label_vals.c,v 1.16 2015/08/24 18:22:05 fischl Exp $", "$Name: $");
if (nargs && argc - nargs == 1)
exit (0);
argc -= nargs;
Progname = argv[0] ;
ErrorInit(NULL, NULL, NULL) ;
DiagInit(NULL, NULL, NULL) ;
TimerStart(&start) ;
ac = argc ;
av = argv ;
for ( ; argc > 1 && ISOPTION(*argv[1]) ; argc--, argv++) {
nargs = get_option(argc, argv) ;
argc -= nargs ;
argv += nargs ;
}
if (argc < 3)
usage_exit(1) ;
vol_name = argv[1] ;
label_name = argv[2] ;
out_name = argv[3] ;
mri = MRIread(vol_name) ;
if (!mri)
ErrorExit(ERROR_NOFILE, "%s: could not read volume from %s",Progname, vol_name) ;
if (scaleup_flag) {
float scale, fov_x, fov_y, fov_z ;
scale = 1.0/MIN(MIN(mri->xsize, mri->ysize),mri->zsize) ;
fprintf(stderr, "scaling voxel sizes up by %2.2f\n", scale) ;
mri->xsize *= scale ;
mri->ysize *= scale ;
mri->zsize *= scale ;
fov_x = mri->xsize * mri->width;
fov_y = mri->ysize * mri->height;
fov_z = mri->zsize * mri->depth;
mri->xend = fov_x / 2.0;
mri->xstart = -mri->xend;
mri->yend = fov_y / 2.0;
mri->ystart = -mri->yend;
mri->zend = fov_z / 2.0;
mri->zstart = -mri->zend;
mri->fov = (fov_x > fov_y ? (fov_x > fov_z ? fov_x : fov_z) : (fov_y > fov_z ? fov_y : fov_z) );
}
if (segmentation_flag >= 0) {
int x, y, z ;
VECTOR *v_seg, *v_mri ;
MATRIX *m_seg_to_mri ;
v_seg = VectorAlloc(4, MATRIX_REAL) ;
v_mri = VectorAlloc(4, MATRIX_REAL) ;
VECTOR_ELT(v_seg, 4) = 1.0 ;
VECTOR_ELT(v_mri, 4) = 1.0 ;
mri_seg = MRIread(argv[2]) ;
if (!mri_seg)
ErrorExit(ERROR_NOFILE, "%s: could not read volume from %s",Progname, argv[2]) ;
if (erode) {
MRI *mri_tmp ;
mri_tmp = MRIclone(mri_seg, NULL) ;
MRIcopyLabel(mri_seg, mri_tmp, segmentation_flag) ;
while (erode-- > 0)
MRIerode(mri_tmp, mri_tmp) ;
MRIcopy(mri_tmp, mri_seg) ;
MRIfree(&mri_tmp) ;
}
m_seg_to_mri = MRIgetVoxelToVoxelXform(mri_seg, mri) ;
for (x = 0 ; x < mri_seg->width ; x++) {
V3_X(v_seg) = x ;
for (y = 0 ; y < mri_seg->height ; y++) {
V3_Y(v_seg) = y ;
for (z = 0 ; z < mri_seg->depth ; z++) {
V3_Z(v_seg) = z ;
if (MRIvox(mri_seg, x, y, z) == segmentation_flag) {
MatrixMultiply(m_seg_to_mri, v_seg, v_mri) ;
xv = V3_X(v_mri) ;
yv = V3_Y(v_mri) ;
zv = V3_Z(v_mri) ;
MRIsampleVolumeType(mri, xv, yv, zv, &val, SAMPLE_NEAREST);
#if 0
if (val < .000001) {
val *= 1000000;
printf("%f*0.000001\n", val);
} else
#endif
if (coords)
printf("%2.1f %2.1f %2.1f %f\n", xv, yv, zv, val);
else
printf("%f\n", val);
}
}
}
}
MatrixFree(&m_seg_to_mri) ;
VectorFree(&v_seg) ;
VectorFree(&v_mri) ;
} else {
if (cras == 1)
fprintf(stderr,"using the label coordinates to be c_(r,a,s) != 0.\n");
if (surface_dir) {
MRI_SURFACE *mris ;
char fname[STRLEN] ;
sprintf(fname, "%s/%s.white", surface_dir, hemi) ;
mris = MRISread(fname) ;
if (mris == NULL)
ErrorExit(ERROR_NOFILE, "%s: could not read surface file %s...\n", Progname,fname) ;
sprintf(fname, "%s/%s.thickness", surface_dir, hemi) ;
if (MRISreadCurvatureFile(mris, fname) != NO_ERROR)
ErrorExit(ERROR_BADPARM, "%s: could not read thickness file %s...\n", Progname,fname) ;
if (annot_prefix) /* read an annotation in and print vals in it */
{
#define MAX_ANNOT 10000
int vno, annot_counts[MAX_ANNOT], index ;
VERTEX *v ;
Real xw, yw, zw, xv, yv, zv, val ;
float annot_means[MAX_ANNOT] ;
FILE *fp ;
memset(annot_means, 0, sizeof(annot_means)) ;
memset(annot_counts, 0, sizeof(annot_counts)) ;
if (MRISreadAnnotation(mris, label_name) != NO_ERROR)
ErrorExit(ERROR_BADPARM, "%s: could not read annotation file %s...\n", Progname,fname) ;
if (mris->ct == NULL)
ErrorExit(ERROR_BADPARM, "%s: annot file does not contain a color table, specifiy one with -t ", Progname);
for (vno = 0 ; vno < mris->nvertices ; vno++) {
v = &mris->vertices[vno] ;
if (v->ripflag)
continue ;
CTABfindAnnotation(mris->ct, v->annotation, &index) ;
if (index >= 0 && index < mris->ct->nentries) {
annot_counts[index]++ ;
xw = v->x + v->curv*.5*v->nx ;
yw = v->y + v->curv*.5*v->ny ;
zw = v->z + v->curv*.5*v->nz ;
if (cras == 1)
MRIworldToVoxel(mri, xw, yw, zw, &xv, &yv, &zv) ;
else
MRIsurfaceRASToVoxel(mri, xw, yw, zw, &xv, &yv, &zv);
MRIsampleVolume(mri, xv, yv, zv, &val) ;
annot_means[index] += val ;
sprintf(fname, "%s-%s-%s.dat", annot_prefix, hemi, mris->ct->entries[index]->name) ;
fp = fopen(fname, "a") ;
fprintf(fp, "%f\n", val) ;
fclose(fp) ;
}
}
}
else /* read label in and print vals in it */
{
area = LabelRead(NULL, label_name) ;
if (!area)
ErrorExit(ERROR_NOFILE, "%s: could not read label from %s",Progname, label_name) ;
}
} else {
area = LabelRead(NULL, label_name) ;
if (!area)
ErrorExit(ERROR_NOFILE, "%s: could not read label from %s",Progname, label_name) ;
for (i = 0 ; i < area->n_points ; i++) {
xw = area->lv[i].x ;
yw = area->lv[i].y ;
zw = area->lv[i].z ;
if (cras == 1)
MRIworldToVoxel(mri, xw, yw, zw, &xv, &yv, &zv) ;
else
MRIsurfaceRASToVoxel(mri, xw, yw, zw, &xv, &yv, &zv);
MRIsampleVolumeType(mri, xv, yv, zv, &val, SAMPLE_NEAREST);
#if 0
if (val < .000001) {
val *= 1000000;
printf("%f*0.000001\n", val);
} else
#endif
printf("%f\n", val);
}
}
}
msec = TimerStop(&start) ;
seconds = nint((float)msec/1000.0f) ;
minutes = seconds / 60 ;
seconds = seconds % 60 ;
if (DIAG_VERBOSE_ON)
fprintf(stderr, "label value extractiong took %d minutes and %d seconds.\n",
minutes, seconds) ;
exit(0) ;
return(0) ;
}
int
main(int argc, char *argv[]) {
char **av, fname[STRLEN], *input_name, *subject_name, *cp,*hemi,
*svm_name, *surf_name, *output_subject_name ;
int ac, nargs, vno ;
int msec, minutes, seconds ;
struct timeb start ;
MRI_SURFACE *mris ;
SVM *svm ;
double classification ;
float *inputs ;
MRI_SP *mrisp ;
/* rkt: check for and handle version tag */
nargs = handle_version_option (argc, argv, "$Id: mris_svm_classify.c,v 1.6 2011/03/02 00:04:34 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 (!strlen(subjects_dir)) /* hasn't been set on command line */
{
cp = getenv("SUBJECTS_DIR") ;
if (!cp)
ErrorExit(ERROR_BADPARM, "%s: SUBJECTS_DIR not defined in environment",
Progname);
strcpy(subjects_dir, cp) ;
}
if (argc < 7)
usage_exit(1) ;
subject_name = argv[1] ;
hemi = argv[2] ;
surf_name = argv[3] ;
input_name = argv[4] ;
output_subject_name = argv[5] ;
svm_name = argv[6] ;
printf("reading svm from %s...\n", svm_name) ;
svm = SVMread(svm_name) ;
if (!svm)
ErrorExit(ERROR_NOFILE, "%s: could not read classifier from %s",
Progname, svm_name) ;
if (log_fname != NULL)
printf("logging results to %s, true_class = %s\n",
log_fname, true_class > 0 ? svm->class1_name : svm->class2_name) ;
sprintf(fname, "%s/%s/surf/%s.%s", subjects_dir,subject_name,hemi,surf_name);
printf("reading surface from %s...\n", fname) ;
mris = MRISread(fname) ;
if (!mris)
ErrorExit(ERROR_NOFILE, "%s: could not read surface file %s for %s",
Progname, fname, subject_name) ;
MRISsaveVertexPositions(mris, CANONICAL_VERTICES) ;
if (MRISreadCurvature(mris, input_name) != NO_ERROR)
ErrorExit(ERROR_BADPARM, "%s: could not read curvature from %s", input_name) ;
if (nannotations > 0)
{
int vno, a, found ;
VERTEX *v ;
if (MRISreadAnnotation(mris, annot_name) != NO_ERROR)
ErrorExit(ERROR_NOFILE,
"%s: could not read annot file %s for subject %s",
Progname, annot_name, subject_name) ;
for (a = 0 ; a < nannotations ; a++)
{
int index ;
CTABfindName(mris->ct, anames[a], &index) ;
CTABannotationAtIndex(mris->ct, index, &annotations[a]) ;
printf("mapping annot %s to %d\n",
anames[a], annotations[a]) ;
}
// rip all vertices that don't have one of the specified annotations
for (vno = 0 ; vno < mris->nvertices ; vno++)
{
v = &mris->vertices[vno] ;
if (v->ripflag)
continue ;
found = 0 ;
for (a = 0 ; a < nannotations ; a++)
if (v->annotation == annotations[a])
found = 1 ;
if (found == 0)
v->ripflag = 1 ;
}
}
if (navgs > 0)
MRISaverageCurvatures(mris, navgs) ;
mrisp = MRIStoParameterization(mris, NULL, 1, 0) ;
MRISfree(&mris) ;
/* read in output surface */
sprintf(fname, "%s/%s/surf/%s.%s", subjects_dir,output_subject_name,hemi,surf_name);
printf("reading output surface from %s...\n", fname) ;
mris = MRISread(fname) ;
if (!mris)
ErrorExit(ERROR_NOFILE, "%s: could not read surface file %s for %s",
Progname, fname, output_subject_name) ;
MRISsaveVertexPositions(mris, CANONICAL_VERTICES) ;
MRISfromParameterization(mrisp, mris, 0) ;
if (label_name) {
area = LabelRead(output_subject_name, label_name) ;
if (!area)
ErrorExit(ERROR_NOFILE, "%s: could not read label %s", Progname,
label_name) ;
MRISmaskNotLabel(mris, area) ;
} else
area = NULL ;
if (mris->nvertices != svm->ninputs)
ErrorExit(ERROR_BADPARM, "%s: svm input (%d) does not match # of "
"surface vertices (%d)",
Progname, svm->ninputs, mris->nvertices);
inputs = (float *)calloc(mris->nvertices, sizeof(float)) ;
if (!inputs)
ErrorExit(ERROR_NOMEMORY, "%s: could not allocate %d input vector",
Progname, mris->nvertices) ;
for (vno = 0 ; vno < mris->nvertices ; vno++)
inputs[vno] = mris->vertices[vno].curv ;
classification = SVMclassify(svm, inputs) ;
printf("classification %f, class = %s",classification,
classification > 0 ? svm->class1_name : svm->class2_name) ;
if (true_class != 0)
printf(", %s", true_class*classification>0 ? "CORRECT" : "INCORRECT") ;
printf("\n") ;
if (log_fname) {
FILE *fp ;
fp = fopen(log_fname, "a") ;
if (!fp)
ErrorExit(ERROR_BADPARM, "%s: could not open log file %s", log_fname) ;
fprintf(fp, "%-30.30s %s %d %f %f\n",
subject_name, hemi, (true_class*classification)>0, classification,
true_class) ;
fclose(fp) ;
}
free(inputs) ;
MRISfree(&mris) ;
SVMfree(&svm) ;
msec = TimerStop(&start) ;
seconds = nint((float)msec/1000.0f) ;
minutes = seconds / 60 ;
seconds = seconds % 60 ;
printf("classification took %d minutes and %d seconds.\n", minutes, seconds) ;
exit(0) ;
return(0) ;
}
/*----------------------------------------------------------------------
Parameters:
Description:
----------------------------------------------------------------------*/
static int
get_option(int argc, char *argv[])
{
int n,nargs = 0 ;
char *option ;
float f ;
option = argv[1] + 1 ; /* past '-' */
if (!stricmp(option, "-help")||!stricmp(option, "-usage"))
{
print_help() ;
}
else if (!stricmp(option, "-version"))
{
print_version() ;
}
else if (!stricmp(option, "median"))
{
which_norm = NORM_MEDIAN ;
printf("using median normalization\n") ;
}
else if (!stricmp(option, "vnum") || !stricmp(option, "distances"))
{
parms.nbhd_size = atof(argv[2]) ;
parms.max_nbrs = atof(argv[3]) ;
nargs = 2 ;
fprintf(stderr, "nbr size = %d, max neighbors = %d\n",
parms.nbhd_size, parms.max_nbrs) ;
}
else if (!stricmp(option, "nonorm"))
{
which_norm = NORM_NONE ;
printf("disabling normalization\n") ;
}
else if (!stricmp(option, "vsmooth"))
{
parms.var_smoothness = 1 ;
printf("using space/time varying smoothness weighting\n") ;
}
else if (!stricmp(option, "sigma"))
{
if (nsigmas >= MAX_SIGMAS)
{
ErrorExit(ERROR_NOMEMORY, "%s: too many sigmas specified (%d)\n",
Progname, nsigmas) ;
}
sigmas[nsigmas] = atof(argv[2]) ;
nargs = 1 ;
nsigmas++ ;
}
else if (!stricmp(option, "vector"))
{
fprintf(stderr,
"\nMultiframe Mode:\n");
fprintf(stderr,
"Use -addframe option to add extra-fields into average atlas\n");
fprintf(stderr,
"\t-addframe which_field where_in_atlas l_corr l_pcorr\n");
fprintf(stderr,
"\tfield code:\n");
for (n=0 ; n < NUMBER_OF_VECTORIAL_FIELDS ; n++)
fprintf(stderr,
"\t field %d is '%s' (type = %d)\n",
n,ReturnFieldName(n),IsDistanceField(n));
exit(1);
}
else if (!stricmp(option, "annot"))
{
annot_name = argv[2] ;
fprintf(stderr,"zeroing medial wall in %s\n", annot_name) ;
nargs=1;
}
else if (!stricmp(option, "init"))
{
use_initial_registration=1;
fprintf(stderr,"use initial registration\n");
}
else if (!stricmp(option, "addframe"))
{
int which_field,where_in_atlas;
float l_corr,l_pcorr;
if (multiframes==0)
{
/* activate multiframes mode */
initParms();
multiframes = 1;
}
which_field=atoi(argv[2]);
where_in_atlas=atoi(argv[3]);
l_corr=atof(argv[4]);
l_pcorr=atof(argv[5]);
fprintf(stderr,
"adding field %d (%s) with location %d in the atlas\n",
which_field,ReturnFieldName(which_field),where_in_atlas) ;
/* check if this field exist or not */
for (n = 0 ; n < parms.nfields ; n++)
{
if (parms.fields[n].field==which_field)
{
fprintf(stderr,"ERROR: field already exists\n");
exit(1);
}
}
/* adding field into parms */
n=parms.nfields++;
SetFieldLabel(&parms.fields[n],
which_field,
where_in_atlas,
l_corr,
l_pcorr,
0,
which_norm);
nargs = 4 ;
}
/* else if (!stricmp(option, "hippocampus")) */
/* { */
/* if(multiframes==0){ */
/* multiframes = 1 ; */
/* initParms(); */
/* } */
/* where=atoi(argv[2]); */
/* parms.l_corrs[]=atof(argv[3]); */
/* parms.l_pcorrs[]=atof(argv[4]); */
/* parms.frames[]=; */
/* parms. */
/* fprintf(stderr, "using hippocampus distance map\n") ; */
/* nargs=3; */
/* } */
else if (!stricmp(option, "topology"))
{
parms.flags |= IPFLAG_PRESERVE_SPHERICAL_POSITIVE_AREA;
fprintf(stderr, "preserving the topology of positive area triangles\n");
}
else if (!stricmp(option, "vnum") || !stricmp(option, "distances"))
{
parms.nbhd_size = atof(argv[2]) ;
parms.max_nbrs = atof(argv[3]) ;
nargs = 2 ;
fprintf(stderr, "nbr size = %d, max neighbors = %d\n",
parms.nbhd_size, parms.max_nbrs) ;
}
else if (!stricmp(option, "rotate"))
{
dalpha = atof(argv[2]) ;
dbeta = atof(argv[3]) ;
dgamma = atof(argv[4]) ;
fprintf(stderr, "rotating brain by (%2.2f, %2.2f, %2.2f)\n",
dalpha, dbeta, dgamma) ;
nargs = 3 ;
}
else if (!stricmp(option, "reverse"))
{
reverse_flag = 1 ;
fprintf(stderr, "mirror image reversing brain before morphing...\n") ;
}
else if (!stricmp(option, "min_degrees"))
{
min_degrees = atof(argv[2]) ;
fprintf(stderr,
"setting min angle for search to %2.2f degrees\n",
min_degrees) ;
nargs = 1 ;
}
else if (!stricmp(option, "max_degrees"))
{
max_degrees = atof(argv[2]) ;
fprintf(stderr,
"setting max angle for search to %2.2f degrees\n",
max_degrees) ;
nargs = 1 ;
}
else if (!stricmp(option, "nangles"))
{
nangles = atoi(argv[2]) ;
fprintf(stderr, "setting # of angles/search per scale to %d\n", nangles) ;
nargs = 1 ;
}
else if (!stricmp(option, "jacobian"))
{
jacobian_fname = argv[2] ;
nargs = 1 ;
printf("writing out jacobian of mapping to %s\n", jacobian_fname) ;
}
else if (!stricmp(option, "dist"))
{
sscanf(argv[2], "%f", &parms.l_dist) ;
nargs = 1 ;
use_defaults = 0 ;
fprintf(stderr, "l_dist = %2.3f\n", parms.l_dist) ;
}
else if (!stricmp(option, "norot"))
{
fprintf(stderr, "disabling initial rigid alignment...\n") ;
parms.flags |= IP_NO_RIGID_ALIGN ;
}
else if (!stricmp(option, "inflated"))
{
fprintf(stderr, "using inflated surface for initial alignment\n") ;
parms.flags |= IP_USE_INFLATED ;
}
else if (!stricmp(option, "multi_scale"))
{
multi_scale = atoi(argv[2]) ;
fprintf(stderr, "using %d scales for morphing\n", multi_scale) ;
nargs = 1 ;
}
else if (!stricmp(option, "nsurfaces"))
{
parms.nsurfaces = atoi(argv[2]) ;
nargs = 1 ;
fprintf(stderr,
"using %d surfaces/curvatures for alignment\n",
parms.nsurfaces) ;
}
else if (!stricmp(option, "infname"))
{
char fname[STRLEN] ;
inflated_name = argv[2] ;
surface_names[0] = argv[2] ;
nargs = 1 ;
printf("using %s as inflated surface name, "
"and using it for initial alignment\n", inflated_name) ;
sprintf(fname, "%s.H", argv[2]) ;
curvature_names[0] = (char *)calloc(strlen(fname)+1, sizeof(char)) ;
strcpy(curvature_names[0], fname) ;
parms.flags |= IP_USE_INFLATED ;
}
else if (!stricmp(option, "nosulc"))
{
fprintf(stderr, "disabling initial sulc alignment...\n") ;
parms.flags |= IP_NO_SULC ;
}
else if (!stricmp(option, "sulc"))
{
curvature_names[1] = argv[2] ;
fprintf(stderr, "using %s to replace 'sulc' alignment\n",
curvature_names[1]) ;
nargs = 1 ;
MRISsetSulcFileName(argv[2]);
}
else if (!stricmp(option, "surf0"))
{
surface_names[0] = argv[2];
fprintf(stderr, "using %s as input surface 0.\n",
surface_names[0]) ;
nargs = 1 ;
}
else if (!stricmp(option, "surf1"))
{
surface_names[1] = argv[2];
fprintf(stderr, "using %s as input surface 1.\n",
surface_names[1]) ;
nargs = 1 ;
}
else if (!stricmp(option, "surf2"))
{
surface_names[2] = argv[2];
fprintf(stderr, "using %s as input surface 2.\n",
surface_names[2]) ;
nargs = 1 ;
}
else if (!stricmp(option, "curv0"))
{
curvature_names[0] = argv[2];
fprintf(stderr, "using %s as curvature function for surface 0.\n",
curvature_names[0]) ;
nargs = 1 ;
}
else if (!stricmp(option, "curv1"))
{
curvature_names[1] = argv[2];
fprintf(stderr, "using %s as curvature function for surface 1.\n",
curvature_names[1]) ;
nargs = 1 ;
}
else if (!stricmp(option, "curv2"))
{
curvature_names[2] = argv[2];
fprintf(stderr, "using %s as curvature function for surface 2.\n",
curvature_names[2]) ;
nargs = 1 ;
}
else if (!stricmp(option, "lm"))
{
parms.integration_type = INTEGRATE_LINE_MINIMIZE ;
fprintf(stderr, "integrating with line minimization\n") ;
}
else if (!stricmp(option, "search"))
{
parms.integration_type = INTEGRATE_LM_SEARCH ;
fprintf(stderr, "integrating with binary search line minimization\n") ;
}
else if (!stricmp(option, "dt"))
{
parms.dt = atof(argv[2]) ;
parms.base_dt = .2*parms.dt ;
nargs = 1 ;
fprintf(stderr, "momentum with dt = %2.2f\n", parms.dt) ;
}
else if (!stricmp(option, "area"))
{
use_defaults = 0 ;
sscanf(argv[2], "%f", &parms.l_area) ;
nargs = 1 ;
fprintf(stderr, "using l_area = %2.3f\n", parms.l_area) ;
}
else if (!stricmp(option, "parea"))
{
use_defaults = 0 ;
sscanf(argv[2], "%f", &parms.l_parea) ;
nargs = 1 ;
fprintf(stderr, "using l_parea = %2.3f\n", parms.l_parea) ;
}
else if (!stricmp(option, "nlarea"))
{
use_defaults = 0 ;
sscanf(argv[2], "%f", &parms.l_nlarea) ;
nargs = 1 ;
fprintf(stderr, "using l_nlarea = %2.3f\n", parms.l_nlarea) ;
}
else if (!stricmp(option, "spring"))
{
use_defaults = 0 ;
sscanf(argv[2], "%f", &parms.l_spring) ;
nargs = 1 ;
fprintf(stderr, "using l_spring = %2.3f\n", parms.l_spring) ;
}
else if (!stricmp(option, "corr"))
{
use_defaults = 0 ;
sscanf(argv[2], "%f", &parms.l_corr) ;
nargs = 1 ;
fprintf(stderr, "using l_corr = %2.3f\n", parms.l_corr) ;
}
else if (!stricmp(option, "remove_negative"))
{
remove_negative = atoi(argv[2]) ;
nargs = 1 ;
fprintf(stderr, "%sremoving negative triangles with iterative smoothing\n",
remove_negative ? "" : "not ") ;
}
else if (!stricmp(option, "curv"))
{
parms.flags |= IP_USE_CURVATURE ;
fprintf(stderr, "using smoothwm curvature for final alignment\n") ;
}
else if (!stricmp(option, "nocurv"))
{
parms.flags &= ~IP_USE_CURVATURE ;
fprintf(stderr, "NOT using smoothwm curvature for final alignment\n") ;
}
else if (!stricmp(option, "sreg"))
{
starting_reg_fname = argv[2] ;
nargs = 1 ;
fprintf(stderr, "starting registration with coordinates in %s\n",
starting_reg_fname) ;
}
else if (!stricmp(option, "adaptive"))
{
parms.integration_type = INTEGRATE_ADAPTIVE ;
fprintf(stderr, "using adaptive time step integration\n") ;
}
else if (!stricmp(option, "nbrs"))
{
nbrs = atoi(argv[2]) ;
nargs = 1 ;
fprintf(stderr, "using neighborhood size=%d\n", nbrs) ;
}
else if (!stricmp(option, "tol"))
{
if (sscanf(argv[2], "%e", &f) < 1)
ErrorExit(ERROR_BADPARM, "%s: could not scan tol from %s",
Progname, argv[2]) ;
parms.tol = (double)f ;
nargs = 1 ;
fprintf(stderr, "using tol = %2.2e\n", (float)parms.tol) ;
}
else if (!stricmp(option, "error_ratio"))
{
parms.error_ratio = atof(argv[2]) ;
nargs = 1 ;
fprintf(stderr, "error_ratio=%2.3f\n", parms.error_ratio) ;
}
else if (!stricmp(option, "dt_inc"))
{
parms.dt_increase = atof(argv[2]) ;
nargs = 1 ;
fprintf(stderr, "dt_increase=%2.3f\n", parms.dt_increase) ;
}
else if (!stricmp(option, "lap") || !stricmp(option, "lap"))
{
parms.l_lap = atof(argv[2]) ;
nargs = 1 ;
fprintf(stderr, "l_laplacian = %2.3f\n", parms.l_lap) ;
}
else if (!stricmp(option, "vnum"))
{
parms.nbhd_size = atof(argv[2]) ;
parms.max_nbrs = atof(argv[3]) ;
nargs = 2 ;
fprintf(stderr, "nbr size = %d, max neighbors = %d\n",
parms.nbhd_size, parms.max_nbrs) ;
}
else if (!stricmp(option, "dt_dec"))
{
parms.dt_decrease = atof(argv[2]) ;
nargs = 1 ;
fprintf(stderr, "dt_decrease=%2.3f\n", parms.dt_decrease) ;
}
else if (!stricmp(option, "ocorr"))
{
l_ocorr = atof(argv[2]) ;
printf("setting overlay correlation coefficient to %2.1f\n", l_ocorr) ;
nargs = 1 ;
fprintf(stderr, "dt_decrease=%2.3f\n", parms.dt_decrease) ;
}
else if (!stricmp(option, "overlay"))
{
int navgs ;
if (noverlays == 0)
{
atlas_size = 0 ;
}
if (multiframes == 0)
{
initParms() ;
multiframes = 1 ;
}
overlays[noverlays++] = argv[2] ;
navgs = atof(argv[3]) ;
printf("reading overlay from %s and smoothing it %d times\n",
argv[2], navgs) ;
n=parms.nfields++;
SetFieldLabel(&parms.fields[n],
OVERLAY_FRAME,
atlas_size,
l_ocorr,
0.0,
navgs,
which_norm);
SetFieldName(&parms.fields[n], argv[2]) ;
atlas_size++ ;
nargs = 2 ;
}
else if (!stricmp(option, "distance"))
{
int navgs ;
if (noverlays == 0)
{
atlas_size = 0 ;
}
if (multiframes == 0)
{
initParms() ;
multiframes = 1 ;
}
overlays[noverlays++] = argv[2] ;
navgs = atof(argv[3]) ;
printf("reading overlay from %s and smoothing it %d times\n",
argv[2], navgs) ;
n=parms.nfields++;
SetFieldLabel(&parms.fields[n],
DISTANCE_TRANSFORM_FRAME,
atlas_size,
l_ocorr,
0.0,
navgs,
NORM_MAX) ;
SetFieldName(&parms.fields[n], argv[2]) ;
atlas_size++ ;
nargs = 2 ;
}
else if (!stricmp(option, "canon"))
{
canon_name = argv[2] ;
nargs = 1 ;
fprintf(stderr, "using %s for canonical properties...\n", canon_name) ;
}
else if (!stricmp(option, "overlay-dir"))
{
parms.overlay_dir = strcpyalloc(argv[2]) ;
nargs = 1 ;
}
else switch (toupper(*option))
{
case 'M':
parms.integration_type = INTEGRATE_MOMENTUM ;
parms.momentum = atof(argv[2]) ;
nargs = 1 ;
fprintf(stderr, "momentum = %2.2f\n", (float)parms.momentum) ;
break ;
case 'L':
if (nlabels >= MAX_LABELS-1)
ErrorExit(ERROR_NO_MEMORY,
"%s: too many labels specified (%d max)",
Progname, MAX_LABELS) ;
nargs = 3 ;
labels[nlabels] = LabelRead(NULL, argv[2]) ;
if (labels[nlabels] == NULL)
ErrorExit(ERROR_NOFILE,
"%s: could not read label file %s",
Progname, argv[2]) ;
label_gcsa[nlabels] = GCSAread(argv[3]) ;
if (label_gcsa[nlabels] == NULL)
ErrorExit(ERROR_NOFILE,
"%s: could not read GCSA file %s",
Progname, argv[3]) ;
label_names[nlabels] = argv[4] ;
CTABfindName(label_gcsa[nlabels]->ct, argv[4],&label_indices[nlabels]) ;
if (label_indices[nlabels] < 0)
ErrorExit(ERROR_NOFILE,
"%s: could not map name %s to index",
Progname, argv[3]) ;
CTABannotationAtIndex(label_gcsa[nlabels]->ct, label_indices[nlabels],
&label_annots[nlabels]);
nlabels++ ;
gMRISexternalSSE = gcsaSSE ;
break ;
case 'E':
parms.l_external = atof(argv[2]) ;
nargs = 1 ;
printf("setting l_external = %2.1f\n", parms.l_external) ;
break ;
case 'C':
strcpy(curvature_fname, argv[2]) ;
nargs = 1 ;
break ;
case 'A':
sscanf(argv[2], "%d", &parms.n_averages) ;
nargs = 1 ;
fprintf(stderr, "using n_averages = %d\n", parms.n_averages) ;
break ;
case '1':
single_surf = True ;
printf("treating target as a single subject's surface...\n") ;
break ;
case 'S':
scale = atof(argv[2]) ;
fprintf(stderr, "scaling distances by %2.2f\n", scale) ;
nargs = 1 ;
break ;
case 'N':
sscanf(argv[2], "%d", &parms.niterations) ;
nargs = 1 ;
fprintf(stderr, "using niterations = %d\n", parms.niterations) ;
break ;
case 'W':
Gdiag |= DIAG_WRITE ;
sscanf(argv[2], "%d", &parms.write_iterations) ;
nargs = 1 ;
fprintf(stderr,
"using write iterations = %d\n",
parms.write_iterations) ;
break ;
case 'V':
Gdiag_no = atoi(argv[2]) ;
nargs = 1 ;
break ;
case 'O':
orig_name = argv[2] ;
nargs = 1 ;
fprintf(stderr, "using %s for original properties...\n", orig_name) ;
break ;
case 'P':
max_passes = atoi(argv[2]) ;
fprintf(stderr, "limiting unfolding to %d passes\n", max_passes) ;
nargs = 1 ;
break ;
case '?':
case 'H':
case 'U':
print_help() ;
exit(1) ;
break ;
default:
fprintf(stderr, "unknown option %s\n", argv[1]) ;
exit(1) ;
break ;
}
return(nargs) ;
}
int
main(int argc, char *argv[])
{
char **av, in_surf_fname[STRLEN], *in_patch_fname, *out_patch_fname,
fname[STRLEN], path[STRLEN], *cp, hemi[10] ;
int ac, nargs ;
MRI_SURFACE *mris ;
MRI *mri_vertices ;
/* rkt: check for and handle version tag */
nargs = handle_version_option
(argc, argv,
"$Id: mris_flatten.c,v 1.42 2016/12/10 22:57:46 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) ;
Gdiag |= (DIAG_SHOW | DIAG_WRITE) ;
memset(&parms, 0, sizeof(parms)) ;
parms.dt = .1 ;
parms.projection = PROJECT_PLANE ;
parms.tol = 0.2 ;
parms.n_averages = 1024 ;
parms.l_dist = 1.0 ;
parms.l_nlarea = 1.0 ;
parms.niterations = 40 ;
parms.area_coef_scale = 1.0 ;
parms.dt_increase = 1.01 /* DT_INCREASE */;
parms.dt_decrease = 0.98 /* DT_DECREASE*/ ;
parms.error_ratio = 1.03 /*ERROR_RATIO */;
parms.integration_type = INTEGRATE_LINE_MINIMIZE ;
parms.momentum = 0.9 ;
parms.desired_rms_height = -1.0 ;
parms.base_name[0] = 0 ;
parms.nbhd_size = 7 ; /* out to 7-connected neighbors */
parms.max_nbrs = 12 ; /* 12 at each distance */
ac = argc ;
av = argv ;
for ( ; argc > 1 && ISOPTION(*argv[1]) ; argc--, argv++)
{
nargs = get_option(argc, argv) ;
argc -= nargs ;
argv += nargs ;
}
if (argc < 3)
print_help() ;
parms.base_dt = base_dt_scale * parms.dt ;
in_patch_fname = argv[1] ;
out_patch_fname = argv[2] ;
FileNamePath(in_patch_fname, path) ;
cp = strrchr(in_patch_fname, '/') ;
if (!cp)
cp = in_patch_fname ;
cp = strchr(cp, '.') ;
if (cp)
{
strncpy(hemi, cp-2, 2) ;
hemi[2] = 0 ;
}
else
strcpy(hemi, "lh") ;
if (one_surf_flag)
sprintf(in_surf_fname, "%s", in_patch_fname) ;
else
sprintf(in_surf_fname, "%s/%s.%s", path, hemi, original_surf_name) ;
if (parms.base_name[0] == 0)
{
FileNameOnly(out_patch_fname, fname) ;
cp = strchr(fname, '.') ;
if (cp)
strcpy(parms.base_name, cp+1) ;
else
strcpy(parms.base_name, "flattened") ;
}
mris = MRISread(in_surf_fname) ;
if (!mris)
ErrorExit(ERROR_NOFILE, "%s: could not read surface file %s",
Progname, in_surf_fname) ;
if (sphere_flag)
{
MRIScenter(mris, mris) ;
mris->radius = MRISaverageRadius(mris) ;
MRISstoreMetricProperties(mris) ;
MRISsaveVertexPositions(mris, ORIGINAL_VERTICES) ;
}
if (Gdiag_no >= 0)
{
int n ;
printf("vertex %d has %d nbrs before patch:\n",
Gdiag_no, mris->vertices[Gdiag_no].vnum) ;
for (n = 0 ; n < mris->vertices[Gdiag_no].vnum ; n++)
printf("\t%d\n", mris->vertices[Gdiag_no].v[n]) ;
}
if (one_surf_flag) /* only have the 1 surface - no patch file */
{
mris->patch = 1 ;
mris->status = MRIS_PATCH ;
if (!FEQUAL(rescale,1))
{
MRISscaleBrain(mris, mris, rescale) ;
MRIScomputeMetricProperties(mris) ;
}
MRISstoreMetricProperties(mris) ;
MRISsaveVertexPositions(mris, ORIGINAL_VERTICES) ;
}
else
{
MRISresetNeighborhoodSize(mris, mris->vertices[0].nsize) ; // set back to max
if (label_fname) // read in a label instead of a patch
{
LABEL *area ;
area = LabelRead(NULL, label_fname) ;
if (area == NULL)
ErrorExit(ERROR_BADPARM, "%s: could not read label file %s",
Progname, label_fname) ;
LabelDilate(area, mris, dilate_label, CURRENT_VERTICES) ;
MRISclearMarks(mris) ;
LabelMark(area, mris) ;
MRISripUnmarked(mris) ;
MRISripFaces(mris);
mris->patch = 1 ;
mris->status = MRIS_CUT ;
LabelFree(&area) ;
printf("%d valid vertices (%2.1f %% of total)\n",
MRISvalidVertices(mris),
100.0*MRISvalidVertices(mris)/mris->nvertices) ;
}
else
{
if (MRISreadPatch(mris, in_patch_fname) != NO_ERROR)
ErrorExit(ERROR_BADPARM, "%s: could not read patch file %s",
Progname, in_patch_fname) ;
if (dilate)
{
printf("dilating patch %d times\n", dilate) ;
MRISdilateRipped(mris, dilate) ;
printf("%d valid vertices (%2.1f %% of total)\n",
MRISvalidVertices(mris), 100.0*MRISvalidVertices(mris)/mris->nvertices) ;
}
}
MRISremoveRipped(mris) ;
MRISupdateSurface(mris) ;
#if 0
mris->nsize = 1 ; // before recalculation of 2 and 3-nbrs
{
int vno ;
VERTEX *v ;
for (vno= 0 ; vno < mris->nvertices ; vno++)
{
v = &mris->vertices[vno] ;
v->vtotal = v->vnum ;
v->nsize = 1 ;
}
}
MRISsetNeighborhoodSize(mris, nbrs) ;
#endif
}
if (Gdiag_no >= 0)
printf("vno %d is %sin patch\n", Gdiag_no,
mris->vertices[Gdiag_no].ripflag ? "NOT " : "") ;
if (Gdiag_no >= 0 && mris->vertices[Gdiag_no].ripflag == 0)
{
int n ;
printf("vertex %d has %d nbrs after patch:\n",
Gdiag_no, mris->vertices[Gdiag_no].vnum) ;
for (n = 0 ; n < mris->vertices[Gdiag_no].vnum ; n++)
printf("\t%d\n", mris->vertices[Gdiag_no].v[n]) ;
}
fprintf(stderr, "reading original vertex positions...\n") ;
if (!FZERO(disturb))
mrisDisturbVertices(mris, disturb) ;
if (parms.niterations > 0)
{
MRISresetNeighborhoodSize(mris, nbrs) ;
if (!FZERO(parms.l_unfold) || !FZERO(parms.l_expand))
{
static INTEGRATION_PARMS p2 ;
sprintf(in_surf_fname, "%s/%s.%s", path, hemi, original_surf_name) ;
if (stricmp(original_unfold_surf_name,"none") == 0)
{
printf("using current position of patch as initial position\n") ;
MRISstoreMetricProperties(mris) ; /* use current positions */
}
else if (!sphere_flag && !one_surf_flag)
MRISreadOriginalProperties(mris, original_unfold_surf_name) ;
*(&p2) = *(&parms) ;
p2.l_dist = 0 ;
p2.niterations = 100 ;
p2.nbhd_size = p2.max_nbrs = 1 ;
p2.n_averages = 0 ;
p2.write_iterations = parms.write_iterations > 0 ? 25 : 0 ;
p2.tol = -1 ;
p2.dt = 0.5 ;
p2.l_area = 0.0 ;
p2.l_spring = 0.9 ;
p2.l_convex = 0.9 ;
p2.momentum = 0 ;
p2.integration_type = INTEGRATE_MOMENTUM ;
MRISrestoreVertexPositions(mris, ORIGINAL_VERTICES) ;
#if 0
p2.flags |= IPFLAG_NO_SELF_INT_TEST ;
printf("expanding surface....\n") ;
MRISexpandSurface(mris, 4.0, &p2) ; // push it away from fissure
#endif
p2.niterations = 100 ;
MRISunfold(mris, &p2, 1) ;
p2.niterations = 300 ;
p2.l_unfold *= 0.25 ;
MRISunfold(mris, &p2, 1) ;
p2.l_unfold *= 0.25 ;
MRISunfold(mris, &p2, 1) ;
#if 0
printf("smoothing unfolded surface..\n");
p2.niterations = 200 ;
p2.l_unfold = 0 ; // just smooth it
MRISunfold(mris, &p2, max_passes) ;
#endif
parms.start_t = p2.start_t ;
parms.l_unfold = parms.l_convex = parms.l_boundary = parms.l_expand=0 ;
MRIfree(&parms.mri_dist) ;
}
sprintf(in_surf_fname, "%s/%s.%s", path, hemi, original_surf_name) ;
if (!sphere_flag && !one_surf_flag)
MRISreadOriginalProperties(mris, original_surf_name) ;
if (randomly_flatten)
MRISflattenPatchRandomly(mris) ;
else
MRISflattenPatch(mris) ;
/* optimize metric properties of flat map */
fprintf(stderr,"minimizing metric distortion induced by projection...\n");
MRISscaleBrain(mris, mris, scale) ;
MRIScomputeMetricProperties(mris) ;
MRISunfold(mris, &parms, max_passes) ;
MRIScenter(mris, mris) ;
fprintf(stderr, "writing flattened patch to %s\n", out_patch_fname) ;
MRISwritePatch(mris, out_patch_fname) ;
}
if (plane_flag || sphere_flag)
{
char fname[STRLEN] ;
FILE *fp ;
#if 0
sprintf(fname, "%s.%s.out",
mris->hemisphere == RIGHT_HEMISPHERE ? "rh" : "lh",
parms.base_name);
#else
sprintf(fname, "flatten.log") ;
#endif
fp = fopen(fname, "a") ;
if (plane_flag)
MRIScomputeAnalyticDistanceError(mris, MRIS_PLANE, fp) ;
else if (sphere_flag)
MRIScomputeAnalyticDistanceError(mris, MRIS_SPHERE, fp) ;
fclose(fp) ;
}
if (mri_overlay)
{
MRI *mri_flattened ;
char fname[STRLEN] ;
// if it is NxNx1x1 reshape it to be Nx1x1xN
if ( mri_overlay->width == mri_overlay->height &&
mri_overlay->depth == 1 &&
mri_overlay->nframes == 1)
{
MRI *mri_tmp ;
printf("reshaping to move 2nd dimension to time\n") ;
mri_tmp = mri_reshape( mri_overlay, mri_overlay->width, 1, 1, mri_overlay->height);
MRIfree( &mri_overlay );
mri_overlay = mri_tmp;
}
// put in some special code that knows about icosahedra
if (mris->nvertices == 163842 || // ic7
mris->nvertices == 40962 || // ic6
mris->nvertices == 10242 || // ic5
mris->nvertices == 2562) // ic4
{
int nvals, start_index, end_index ;
MRI *mri_tmp ;
printf("cross-hemispheric correlation matrix detected, reshaping...\n") ;
nvals = mri_overlay->width * mri_overlay->height * mri_overlay->depth ;
if (nvals == 2*mris->nvertices) // it's a corr matrix for both hemis
{
if (mris->hemisphere == LEFT_HEMISPHERE || mris->hemisphere == RIGHT_HEMISPHERE)
{
if (mris->hemisphere == LEFT_HEMISPHERE)
{
start_index = 0 ;
end_index = mris->nvertices-1 ;
}
else
{
start_index = mris->nvertices ;
end_index = 2*mris->nvertices-1 ;
}
mri_tmp = MRIextract(mri_overlay, NULL, start_index, 0, 0, mris->nvertices, 1, 1) ;
MRIfree(&mri_overlay) ;
mri_overlay = mri_tmp;
}
else // both hemis
{
}
}
}
printf("resampling overlay (%d x %d x %d x %d) into flattened coordinates..\n",
mri_overlay->width, mri_overlay->height, mri_overlay->depth, mri_overlay->nframes) ;
if (synth_name)
{
LABEL *area_lh, *area_rh ;
char fname[STRLEN], path[STRLEN], fname_no_path[STRLEN] ;
int vno, n, vno2, n2 ;
MRIsetValues(mri_overlay, 0) ;
FileNameOnly(synth_name, fname_no_path) ;
FileNamePath(synth_name, path) ;
sprintf(fname, "%s/lh.%s", path, fname_no_path) ;
area_lh = LabelRead(NULL, fname) ;
if (area_lh == NULL)
ErrorExit(ERROR_NOFILE, "%s: could not read label from %s",
Progname,fname) ;
sprintf(fname, "%s/rh.%s", path, fname_no_path) ;
area_rh = LabelRead(NULL, fname) ;
if (area_rh == NULL)
ErrorExit(ERROR_NOFILE, "%s: could not read label from %s",
Progname,fname) ;
#if 0
for (n = 0 ; n < area_lh->n_points ; n++)
{
vno = area_lh->lv[n].vno ;
MRIsetVoxVal(mri_overlay, vno, 0, 0, vno, 1) ;
printf("synthesizing map with vno %d: (%2.1f, %2.1f)\n", vno, mris->vertices[vno].x, mris->vertices[vno].y) ;
break ;
}
#else
for (n = 0 ; n < area_lh->n_points ; n++)
{
vno = area_lh->lv[n].vno ;
if (vno >= 0)
{
for (n2 = 0 ; n2 < area_lh->n_points ; n2++)
{
vno2 = area_lh->lv[n2].vno ;
if (vno2 >= 0)
MRIsetVoxVal(mri_overlay, vno, 0, 0, vno2, 1) ;
}
for (n2 = 0 ; n2 < area_rh->n_points ; n2++)
{
vno2 = area_rh->lv[n2].vno ;
if (vno2 >= 0)
MRIsetVoxVal(mri_overlay, vno, 0, 0, mris->nvertices+vno2, 1) ;
}
}
}
#endif
}
mri_flattened = MRIflattenOverlay(mris, mri_overlay, NULL, 1.0, label_overlay, &mri_vertices) ;
printf("writing flattened overlay to %s\n", out_patch_fname) ;
MRIwrite(mri_flattened, out_patch_fname) ;
MRIfree(&mri_flattened) ;
FileNameRemoveExtension(out_patch_fname, fname) ;
strcat(fname, ".vnos.mgz") ;
printf("writing flattened vertex #s to %s\n", fname) ;
MRIwrite(mri_vertices, fname) ;
MRIfree(&mri_vertices) ;
}
#if 0
sprintf(fname, "%s.area_error", out_fname) ;
printf("writing area errors to %s\n", fname) ;
MRISwriteAreaError(mris, fname) ;
sprintf(fname, "%s.angle_error", out_fname) ;
printf("writing angle errors to %s\n", fname) ;
MRISwriteAngleError(mris, fname) ;
MRISfree(&mris) ;
#endif
exit(0) ;
return(0) ; /* for ansi */
}
/*----------------------------------------------------------------------
Parameters:
Description:
----------------------------------------------------------------------*/
static int
get_option(int argc, char *argv[])
{
int nargs = 0 ;
char *option ;
float f ;
option = argv[1] + 1 ; /* past '-' */
if (!stricmp(option, "-help"))
{
print_help() ;
}
else if (!stricmp(option, "-version"))
{
print_version() ;
}
else if (!stricmp(option, "synth"))
{
synth_name = argv[2] ;
nargs = 1 ;
}
else if (!stricmp(option, "overlay"))
{
mri_overlay = MRIread(argv[2]) ;
nargs = 1 ;
if (mri_overlay == NULL)
ErrorExit(ERROR_NOFILE, "%s: could not read overlay from %s", argv[2]) ;
parms.niterations = 0 ; // this will disable the actual flattening
}
else if (!stricmp(option, "label_overlay") || !stricmp(option, "overlay_label"))
{
label_overlay = LabelRead(NULL, argv[2]) ;
nargs = 1 ;
if (label_overlay == NULL)
ErrorExit(ERROR_NOFILE, "%s: could not read label overlay from %s", Progname,argv[2]) ;
}
else if (!stricmp(option, "norand"))
{
setRandomSeed(0L) ;
}
else if (!stricmp(option, "sphere"))
{
sphere_flag = 1 ;
}
else if (!stricmp(option, "plane"))
{
plane_flag = 1 ;
}
else if (!stricmp(option, "rescale"))
{
rescale = atof(argv[2]) ;
nargs = 1 ;
fprintf(stderr, "rescaling brain by %2.3f\n", rescale) ;
}
else if (!stricmp(option, "dilate"))
{
dilate = atoi(argv[2]) ;
nargs = 1 ;
fprintf(stderr, "dilating cuts %d times\n", dilate) ;
}
else if (!stricmp(option, "dist"))
{
sscanf(argv[2], "%f", &parms.l_dist) ;
nargs = 1 ;
fprintf(stderr, "l_dist = %2.3f\n", parms.l_dist) ;
}
else if (!stricmp(option, "expand"))
{
sscanf(argv[2], "%f", &parms.l_expand) ;
nargs = 1 ;
printf("setting l_expand = %2.3f\n", parms.l_expand) ;
}
else if (!stricmp(option, "unfold"))
{
MRI *mri_kernel, *mri_tmp ;
sscanf(argv[2], "%f", &parms.l_unfold) ;
mri_tmp = MRIread(argv[3]) ;
if (!mri_tmp)
ErrorExit(ERROR_NOFILE, "%s: could not read distance map %s...\n",
Progname, argv[3]) ;
mri_kernel = MRIgaussian1d(1.0, -1) ;
parms.mri_dist = MRIconvolveGaussian(mri_tmp, NULL, mri_kernel) ;
MRIfree(&mri_kernel) ;
MRIfree(&mri_tmp) ;
nargs = 2 ;
fprintf(stderr, "l_unfold = %2.3f\n", parms.l_unfold) ;
}
else if (!stricmp(option, "boundary"))
{
sscanf(argv[2], "%f", &parms.l_boundary) ;
nargs = 1 ;
fprintf(stderr, "l_boundary = %2.3f\n", parms.l_boundary) ;
}
else if (!stricmp(option, "lm"))
{
parms.integration_type = INTEGRATE_LINE_MINIMIZE ;
fprintf(stderr, "integrating with line minimization\n") ;
}
else if (!stricmp(option, "dt"))
{
parms.dt = atof(argv[2]) ;
parms.base_dt = base_dt_scale*parms.dt ;
nargs = 1 ;
fprintf(stderr, "momentum with dt = %2.2f\n", parms.dt) ;
}
else if (!stricmp(option, "curv"))
{
sscanf(argv[2], "%f", &parms.l_curv) ;
nargs = 1 ;
fprintf(stderr, "using l_curv = %2.3f\n", parms.l_curv) ;
}
else if (!stricmp(option, "nospring"))
{
nospring = 1 ;
}
else if (!stricmp(option, "area"))
{
sscanf(argv[2], "%f", &parms.l_area) ;
nargs = 1 ;
fprintf(stderr, "using l_area = %2.3f\n", parms.l_area) ;
}
else if (!stricmp(option, "nlarea"))
{
sscanf(argv[2], "%f", &parms.l_nlarea) ;
nargs = 1 ;
fprintf(stderr, "using l_nlarea = %2.3f\n", parms.l_nlarea) ;
}
else if (!stricmp(option, "boundary"))
{
sscanf(argv[2], "%f", &parms.l_boundary) ;
nargs = 1 ;
fprintf(stderr, "using l_boundary = %2.3f\n", parms.l_boundary) ;
}
else if (!stricmp(option, "adaptive"))
{
parms.integration_type = INTEGRATE_ADAPTIVE ;
fprintf(stderr, "using adaptive time step integration\n") ;
}
else if (!stricmp(option, "nbrs"))
{
nbrs = atoi(argv[2]) ;
nargs = 1 ;
fprintf(stderr, "using neighborhood size=%d\n", nbrs) ;
}
else if (!stricmp(option, "spring"))
{
sscanf(argv[2], "%f", &parms.l_spring) ;
nargs = 1 ;
fprintf(stderr, "using l_spring = %2.3f\n", parms.l_spring) ;
}
else if (!stricmp(option, "name"))
{
strcpy(parms.base_name, argv[2]) ;
nargs = 1 ;
fprintf(stderr, "using base name = %s\n", parms.base_name) ;
}
else if (!stricmp(option, "angle"))
{
sscanf(argv[2], "%f", &parms.l_angle) ;
nargs = 1 ;
fprintf(stderr, "using l_angle = %2.3f\n", parms.l_angle) ;
}
else if (!stricmp(option, "area"))
{
sscanf(argv[2], "%f", &parms.l_area) ;
nargs = 1 ;
fprintf(stderr, "using l_area = %2.3f\n", parms.l_area) ;
}
else if (!stricmp(option, "tol"))
{
if (sscanf(argv[2], "%e", &f) < 1)
ErrorExit(ERROR_BADPARM, "%s: could not scan tol from %s",
Progname, argv[2]) ;
parms.tol = (double)f ;
nargs = 1 ;
fprintf(stderr, "using tol = %2.2e\n", (float)parms.tol) ;
}
else if (!stricmp(option, "error_ratio"))
{
parms.error_ratio = atof(argv[2]) ;
nargs = 1 ;
fprintf(stderr, "error_ratio=%2.3f\n", parms.error_ratio) ;
}
else if (!stricmp(option, "dt_inc"))
{
parms.dt_increase = atof(argv[2]) ;
nargs = 1 ;
fprintf(stderr, "dt_increase=%2.3f\n", parms.dt_increase) ;
}
else if (!stricmp(option, "complete"))
{
parms.complete_dist_mat = 1 ;
fprintf(stderr, "using complete distance matrix\n") ;
}
else if (!stricmp(option, "vnum") || (!stricmp(option, "distances")))
{
parms.nbhd_size = atof(argv[2]) ;
parms.max_nbrs = atof(argv[3]) ;
nargs = 2 ;
fprintf(stderr, "sampling %d neighbors out to a distance of %d mm\n",
parms.max_nbrs, parms.nbhd_size) ;
}
else if (!stricmp(option, "dt_dec"))
{
parms.dt_decrease = atof(argv[2]) ;
nargs = 1 ;
fprintf(stderr, "dt_decrease=%2.3f\n", parms.dt_decrease) ;
}
else if (!stricmp(option, "ou"))
{
original_unfold_surf_name = argv[2] ;
nargs = 1 ;
fprintf(stderr,"reading original unfolding surface from %s...\n",
original_unfold_surf_name);
}
else if (!stricmp(option, "as"))
{
parms.area_coef_scale = atof(argv[2]) ;
printf("setting area coef scale to %2.3f\n",
parms.area_coef_scale) ;
nargs = 1 ;
}
else switch (toupper(*option))
{
case 'P':
max_passes = atoi(argv[2]) ;
fprintf(stderr, "limitting unfolding to %d passes\n", max_passes) ;
nargs = 1 ;
break ;
case '1':
one_surf_flag = 1 ; /* patch is only surface file */
break ;
case 'O':
original_surf_name = argv[2] ;
nargs = 1 ;
fprintf(stderr,"reading original surface from %s...\n",
original_surf_name);
break ;
case 'B':
base_dt_scale = atof(argv[2]) ;
parms.base_dt = base_dt_scale*parms.dt ;
nargs = 1;
break ;
case 'V':
Gdiag_no = atoi(argv[2]) ;
nargs = 1 ;
break ;
case 'L':
label_fname = argv[2] ;
dilate_label = atof(argv[3]) ;
nargs = 2;
printf("loading label %s and dilating it %d times before flattening\n",
label_fname, dilate_label) ;
break ;
case 'D':
disturb = atof(argv[2]) ;
nargs = 1 ;
fprintf(stderr, "disturbing vertex positions by %2.3f\n",
(float)disturb) ;
break ;
case 'R':
randomly_flatten = !randomly_flatten ;
fprintf(stderr, "using random placement for flattening.\n") ;
break ;
case 'M':
parms.integration_type = INTEGRATE_MOMENTUM ;
parms.momentum = atof(argv[2]) ;
nargs = 1 ;
fprintf(stderr, "momentum = %2.2f\n", (float)parms.momentum) ;
break ;
case 'S':
scale = atof(argv[2]) ;
fprintf(stderr, "scaling brain by = %2.3f\n", (float)scale) ;
nargs = 1 ;
break ;
case 'W':
Gdiag |= DIAG_WRITE ;
sscanf(argv[2], "%d", &parms.write_iterations) ;
nargs = 1 ;
fprintf(stderr, "using write iterations = %d\n",
parms.write_iterations) ;
break ;
case 'I':
inflate = 1 ;
fprintf(stderr, "inflating brain...\n") ;
break ;
case 'A':
sscanf(argv[2], "%d", &parms.n_averages) ;
nargs = 1 ;
fprintf(stderr, "using n_averages = %d\n", parms.n_averages) ;
break ;
case 'N':
sscanf(argv[2], "%d", &parms.niterations) ;
nargs = 1 ;
fprintf(stderr, "using niterations = %d\n", parms.niterations) ;
break ;
default:
case 'H':
case '?':
case 'U':
print_help() ;
break ;
}
return(nargs) ;
}
int
main(int argc, char *argv[]) {
MRI_SURFACE *mris ;
char **av, *in_label_fname, *out_label_fname, *surf_fname, ext[STRLEN] ; ;
int ac, nargs ;
LABEL *label, *label_out ;
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_label_fname = argv[1] ;
surf_fname = argv[2] ;
out_label_fname = argv[3] ;
printf("reading label from %s...\n", in_label_fname) ;
if (!strcmp(FileNameExtension(in_label_fname, ext), "mgz"))
{
MRI *mri = MRIread(in_label_fname) ;
printf("creating label from volumetric inputs with voxval = %d\n", voxval) ;
if (mri == NULL)
ErrorExit(ERROR_NOFILE, "%s: could not read input volume from %s", Progname, in_label_fname);
label = LabelfromASeg(mri, voxval) ;
MRIfree(&mri) ;
}
else
{
label = LabelRead(NULL, in_label_fname) ;
if (!label)
ErrorExit(ERROR_NOFILE, "%s: could not read label file %s", Progname, in_label_fname) ;
}
printf("reading surface from %s...\n", surf_fname) ;
mris = MRISread(surf_fname) ;
if (!mris)
ErrorExit(ERROR_NOFILE, "%s: could not read surface file %s",Progname, surf_fname) ;
MRISsaveVertexPositions(mris, ORIGINAL_VERTICES) ;
#if 0
LabelFillUnassignedVertices(mris, label) ;
#else
label_out = LabelFillHoles(label, mris, ORIGINAL_VERTICES) ;
#endif
printf("writing sampled label to %s...\n", out_label_fname) ;
LabelWrite(label_out, out_label_fname) ;
MRISfree(&mris) ;
LabelFree(&label) ;
exit(0) ;
return(0) ; /* for ansi */
}
/*---------------------------------------------------------------*/
int main(int argc, char *argv[]) {
int nargs,n,err;
MRIS *SurfReg[100];
MRI *SrcVal, *TrgVal;
char *base;
COLOR_TABLE *ctab=NULL;
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);
// Load in surface registrations
for(n=0; n<nsurfs;n++){
printf("%d Loading %s\n",n+1,SurfRegFile[n]);
base = fio_basename(SurfRegFile[n],".tri");
if(strcmp(base,"ic7")==0){
// Have to do it this way to rescale. Need to find a better more robust way.
printf(" reading as ico 7, rescaling radius to 100\n");
SurfReg[n] = ReadIcoByOrder(7, 100);
}
else
SurfReg[n] = MRISread(SurfRegFile[n]);
free(base);
if(SurfReg[n]==NULL) exit(1);
}
// Load in source data
SrcVal = NULL;
if(DoSynthRand) {
if (SynthSeed < 0) SynthSeed = PDFtodSeed();
printf("INFO: synthesizing, seed = %d\n",SynthSeed);
srand48(SynthSeed);
MRIrandn(SrcVal->width, SrcVal->height, SrcVal->depth,
SrcVal->nframes,0, 1, SrcVal);
}
else if(DoSynthOnes != 0) {
printf("INFO: filling input with all 1s\n");
MRIconst(SrcVal->width, SrcVal->height, SrcVal->depth,
SrcVal->nframes, 1, SrcVal);
}
else if(AnnotFile) {
printf("Loading annotation %s\n",AnnotFile);
err = MRISreadAnnotation(SurfReg[0], AnnotFile);
if(err) exit(1);
SrcVal = MRISannotIndex2Seg(SurfReg[0]);
ctab = CTABdeepCopy(SurfReg[0]->ct);
}
else if(LabelFile) {
LABEL *srclabel;
printf("Loading label %s\n",LabelFile);
srclabel = LabelRead(NULL, LabelFile);
if(srclabel == NULL) exit(1);
SrcVal = MRISlabel2Mask(SurfReg[0],srclabel,NULL);
printf(" %d points in input label\n",srclabel->n_points);
LabelFree(&srclabel);
}
else {
printf("Loading %s\n",SrcValFile);
SrcVal = MRIread(SrcValFile);
if(SrcVal==NULL) exit(1);
}
// Apply registration to source
TrgVal = MRISapplyReg(SrcVal, SurfReg, nsurfs, ReverseMapFlag, DoJac, UseHash);
if(TrgVal == NULL) exit(1);
// Save output
if(AnnotFile){
printf("Converting to target annot\n");
err = MRISseg2annot(SurfReg[nsurfs-1],TrgVal,ctab);
if(err) exit(1);
printf("Writing %s\n",TrgValFile);
MRISwriteAnnotation(SurfReg[nsurfs-1], TrgValFile);
}
else if(LabelFile){
LABEL *label;
label = MRISmask2Label(SurfReg[nsurfs-1], TrgVal, 0, 10e-5);
printf(" %d points in output label\n",label->n_points);
err = LabelWrite(label,TrgValFile);
if(err){
printf("ERROR: writing label file %s\n",TrgValFile);
exit(1);
}
LabelFree(&label);
}
else{
printf("Writing %s\n",TrgValFile);
MRIwrite(TrgVal,TrgValFile);
}
printf("mris_apply_reg done\n");
return 0;
}
/*---------------------------------------------------------------*/
int main(int argc, char *argv[]) {
int nargs, nthlabel, n, vtxno, ano, index, nunhit;
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);
// Make sure subject exists
sprintf(tmpstr,"%s/%s",SUBJECTS_DIR,subject);
if (!fio_IsDirectory(tmpstr)) {
printf("ERROR: cannot find %s\n",tmpstr);
exit(1);
}
if(AnnotPath == NULL){
// Get path to annot, make sure it does not exist
sprintf(tmpstr,"%s/%s/label/%s.%s.annot",
SUBJECTS_DIR,subject,hemi,AnnotName);
if (fio_FileExistsReadable(tmpstr)) {
printf("ERROR: %s already exists\n",tmpstr);
exit(1);
}
AnnotPath = strcpyalloc(tmpstr);
}
// Read the surf
sprintf(tmpstr,"%s/%s/surf/%s.orig",SUBJECTS_DIR,subject,hemi);
printf("Loading %s\n",tmpstr);
mris = MRISread(tmpstr);
if (mris == NULL) exit(1);
// Set up color table
set_atable_from_ctable(ctab);
mris->ct = ctab;
// Set up something to keep track of nhits
nhits = MRIalloc(mris->nvertices,1,1,MRI_INT);
// Set up something to keep track of max stat for that vertex
if (maxstatwinner) maxstat = MRIalloc(mris->nvertices,1,1,MRI_FLOAT);
// Go thru each label
for (nthlabel = 0; nthlabel < nlabels; nthlabel ++) {
label = LabelRead(subject,LabelFiles[nthlabel]);
if (label == NULL) {
printf("ERROR: reading %s\n",LabelFiles[nthlabel]);
exit(1);
}
index = nthlabel;
if (MapUnhitToUnknown) index ++;
ano = index_to_annotation(index);
printf("%2d %2d %s\n",index,ano,index_to_name(index));
for (n = 0; n < label->n_points; n++) {
vtxno = label->lv[n].vno;
if (vtxno < 0 || vtxno > mris->nvertices) {
printf("ERROR: %s, n=%d, vertex %d out of range\n",
LabelFiles[nthlabel],n,vtxno);
exit(1);
}
if(DoLabelThresh && label->lv[n].stat < LabelThresh) continue;
if (maxstatwinner) {
float stat = MRIgetVoxVal(maxstat,vtxno,0,0,0);
if (label->lv[n].stat < stat) {
if (verbose) {
printf("Keeping prior label for vtxno %d "
"(old_stat=%f > this_stat=%f)\n",
vtxno,stat,label->lv[n].stat);
}
continue;
}
MRIsetVoxVal(maxstat,vtxno,0,0,0,label->lv[n].stat);
}
if (verbose) {
if (MRIgetVoxVal(nhits,vtxno,0,0,0) > 0) {
printf
("WARNING: vertex %d maps to multiple labels! (overwriting)\n",
vtxno);
}
}
MRIsetVoxVal(nhits,vtxno,0,0,0,MRIgetVoxVal(nhits,vtxno,0,0,0)+1);
mris->vertices[vtxno].annotation = ano;
//printf("%5d %2d %2d %s\n",vtxno,segid,ano,index_to_name(segid));
} // label ponts
LabelFree(&label);
}// Label
nunhit = 0;
if (MapUnhitToUnknown) {
printf("Mapping unhit to unknown\n");
for (vtxno = 0; vtxno < mris->nvertices; vtxno++) {
if (MRIgetVoxVal(nhits,vtxno,0,0,0) == 0) {
ano = index_to_annotation(0);
mris->vertices[vtxno].annotation = ano;
nunhit ++;
}
}
printf("Found %d unhit vertices\n",nunhit);
}
if (dilate_label_name)
{
dilate_label_into_unknown(mris, dilate_label_annot) ;
}
printf("Writing annot to %s\n",AnnotPath);
MRISwriteAnnotation(mris, AnnotPath);
if (NHitsFile != NULL) MRIwrite(nhits,NHitsFile);
return 0;
}
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[]) {
MRI_SURFACE *mris ;
char **av, *curv_name, *surf_name, *hemi, fname[STRLEN],
*cp, *subject_name, subjects_dir[STRLEN],
**c1_subjects, **c2_subjects ;
int ac, nargs, n, num_class1, num_class2, i, nvertices,
avgs, max_snr_avgs, nlabels = 0, done ;
float **c1_thickness, **c2_thickness, *curvs, *total_mean,
*c1_mean, *c2_mean,
*class_mean, *c1_var, *c2_var, *class_var,*pvals,
**c1_avg_thickness,
*vbest_snr, *vbest_avgs, *vtotal_var, *vsnr, **c2_avg_thickness,
*vbest_pvalues, current_min_label_area, current_fthresh ;
MRI_SP *mrisp ;
LABEL *area, **labels = NULL ;
FILE *fp = NULL ;
double snr, max_snr ;
struct timeb start ;
int msec, minutes, seconds ;
double **c1_label_thickness, **c2_label_thickness ;
int *sorted_indices = NULL, vno ;
float *test_thickness, *test_avg_thickness ;
double label_avg ;
/* rkt: check for and handle version tag */
nargs = handle_version_option (argc, argv, "$Id: mris_classify_thickness.c,v 1.8 2011/03/02 00:04:29 nicks Exp $", "$Name: stable5 $");
if (nargs && argc - nargs == 1)
exit (0);
argc -= nargs;
if (write_flag && DIAG_VERBOSE_ON)
fp = fopen("scalespace.dat", "w") ;
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 ;
}
TimerStart(&start) ;
/* subject_name hemi surface curvature */
if (argc < 7)
usage_exit() ;
if (output_subject == NULL)
ErrorExit(ERROR_BADPARM,
"output subject must be specified with -o <subject name>");
cp = getenv("SUBJECTS_DIR") ;
if (!cp)
ErrorExit(ERROR_BADPARM, "%s: SUBJECTS_DIR not defined in environment",
Progname) ;
strcpy(subjects_dir, cp) ;
hemi = argv[1] ;
surf_name = argv[2] ;
curv_name = argv[3] ;
#define ARGV_OFFSET 4
/* first determine the number of subjects in each class */
num_class1 = 0 ;
n = ARGV_OFFSET ;
do {
num_class1++ ;
n++ ;
if (argv[n] == NULL || n >= argc)
ErrorExit(ERROR_BADPARM, "%s: must spectify ':' between class lists",
Progname) ;
} while (argv[n][0] != ':') ;
/* find # of vertices in output subject surface */
sprintf(fname, "%s/%s/surf/%s.%s",
subjects_dir,output_subject,hemi,surf_name);
mris = MRISread(fname) ;
if (!mris)
ErrorExit(ERROR_NOFILE, "%s: could not read surface file %s",
Progname, fname) ;
nvertices = mris->nvertices ;
MRISfree(&mris) ;
total_mean = (float *)calloc(nvertices, sizeof(float)) ;
if (!total_mean)
ErrorExit(ERROR_NOMEMORY,
"%s: could not allocate mean list of %d curvatures",
Progname, n, nvertices) ;
c1_mean = (float *)calloc(nvertices, sizeof(float)) ;
if (!c1_mean)
ErrorExit(ERROR_NOMEMORY,
"%s: could not allocate c1 mean list of %d curvatures",
Progname, n, nvertices) ;
pvals = (float *)calloc(nvertices, sizeof(float)) ;
if (!pvals)
ErrorExit(ERROR_NOMEMORY,
"%s: could not allocate pvals",
Progname, n, nvertices) ;
c2_mean = (float *)calloc(nvertices, sizeof(float)) ;
if (!c2_mean)
ErrorExit(ERROR_NOMEMORY,
"%s: could not allocate c2 mean list of %d curvatures",
Progname, n, nvertices) ;
c1_var = (float *)calloc(nvertices, sizeof(float)) ;
if (!c1_var)
ErrorExit(ERROR_NOMEMORY,
"%s: could not allocate c1 var list of %d curvatures",
Progname, n, nvertices) ;
c2_var = (float *)calloc(nvertices, sizeof(float)) ;
if (!c2_var)
ErrorExit(ERROR_NOMEMORY,
"%s: could not allocate c2 var list of %d curvatures",
Progname, n, nvertices) ;
num_class2 = 0 ;
n++ ; /* skip ':' */
if (n >= argc)
ErrorExit(ERROR_BADPARM, "%s: class2 list empty", Progname) ;
do {
num_class2++ ;
n++ ;
if (n >= argc)
break ;
} while (argv[n] != NULL) ;
fprintf(stderr, "%d subjects in class 1, %d subjects in class 2\n",
num_class1, num_class2) ;
c1_subjects = (char **)calloc(num_class1, sizeof(char *)) ;
c1_thickness = (float **)calloc(num_class1, sizeof(char *)) ;
c1_avg_thickness = (float **)calloc(num_class1, sizeof(char *)) ;
c2_subjects = (char **)calloc(num_class2, sizeof(char *)) ;
c2_thickness = (float **)calloc(num_class2, sizeof(char *)) ;
c2_avg_thickness = (float **)calloc(num_class2, sizeof(char *)) ;
for (n = 0 ; n < num_class1 ; n++) {
c1_subjects[n] = argv[ARGV_OFFSET+n] ;
c1_thickness[n] = (float *)calloc(nvertices, sizeof(float)) ;
c1_avg_thickness[n] = (float *)calloc(nvertices, sizeof(float)) ;
if (!c1_thickness[n] || !c1_avg_thickness[n])
ErrorExit(ERROR_NOMEMORY,
"%s: could not allocate %dth list of %d curvatures",
Progname, n, nvertices) ;
strcpy(c1_subjects[n], argv[ARGV_OFFSET+n]) ;
/* fprintf(stderr, "class1[%d] - %s\n", n, c1_subjects[n]) ;*/
}
i = n+1+ARGV_OFFSET ; /* starting index */
for (n = 0 ; n < num_class2 ; n++) {
c2_subjects[n] = argv[i+n] ;
c2_thickness[n] = (float *)calloc(nvertices, sizeof(float)) ;
c2_avg_thickness[n] = (float *)calloc(nvertices, sizeof(float)) ;
if (!c2_thickness[n] || !c2_avg_thickness[n])
ErrorExit(ERROR_NOMEMORY,
"%s: could not allocate %dth list of %d curvatures",
Progname, n, nvertices) ;
strcpy(c2_subjects[n], argv[i+n]) ;
/* fprintf(stderr, "class2[%d] - %s\n", n, c2_subjects[n]) ;*/
}
if (label_name) {
area = LabelRead(output_subject, label_name) ;
if (!area)
ErrorExit(ERROR_NOFILE, "%s: could not read label %s", Progname,
label_name) ;
} else
area = NULL ;
if (read_dir) {
sprintf(fname, "%s/%s/surf/%s.%s",
subjects_dir,output_subject,hemi,surf_name);
mris = MRISread(fname) ;
if (!mris)
ErrorExit(ERROR_NOFILE, "%s: could not read surface file %s",
Progname, fname) ;
MRISsaveVertexPositions(mris, CANONICAL_VERTICES) ;
/* real all the curvatures in for group1 */
for (n = 0 ; n < num_class1+num_class2 ; n++) {
/* transform each subject's curvature into the output subject's space */
subject_name = n < num_class1 ? c1_subjects[n]:c2_subjects[n-num_class1];
fprintf(stderr, "reading subject %d of %d: %s\n",
n+1, num_class1+num_class2, subject_name) ;
sprintf(fname, "%s/%s.%s", read_dir,hemi,subject_name);
if (MRISreadValues(mris, fname) != NO_ERROR)
ErrorExit(Gerror,
"%s: could not read curvature file %s",Progname,fname);
if (area)
MRISmaskNotLabel(mris, area) ;
curvs = (n < num_class1) ? c1_thickness[n] : c2_thickness[n-num_class1] ;
class_mean = (n < num_class1) ? c1_mean : c2_mean ;
class_var = (n < num_class1) ? c1_var : c2_var ;
MRISexportValVector(mris, curvs) ;
cvector_accumulate(curvs, total_mean, nvertices) ;
cvector_accumulate(curvs, class_mean, nvertices) ;
cvector_accumulate_square(curvs, class_var, nvertices) ;
}
} else {
/* real all the curvatures in for group1 */
for (n = 0 ; n < num_class1+num_class2 ; n++) {
/* transform each subject's curvature into the output subject's space */
subject_name = n < num_class1 ? c1_subjects[n]:c2_subjects[n-num_class1];
fprintf(stderr, "reading subject %d of %d: %s\n",
n+1, num_class1+num_class2, subject_name) ;
sprintf(fname, "%s/%s/surf/%s.%s",
subjects_dir,subject_name,hemi,surf_name);
mris = MRISread(fname) ;
if (!mris)
ErrorExit(ERROR_NOFILE, "%s: could not read surface file %s",
Progname, fname) ;
MRISsaveVertexPositions(mris, CANONICAL_VERTICES) ;
if (strchr(curv_name, '/') != NULL)
strcpy(fname, curv_name) ; /* full path specified */
else
sprintf(fname,"%s/%s/surf/%s.%s",
subjects_dir,subject_name,hemi,curv_name);
if (MRISreadCurvatureFile(mris, fname) != NO_ERROR)
ErrorExit(Gerror,"%s: could no read curvature file %s",Progname,fname);
mrisp = MRIStoParameterization(mris, NULL, 1, 0) ;
MRISfree(&mris) ;
sprintf(fname, "%s/%s/surf/%s.%s",
subjects_dir,output_subject,hemi,surf_name);
mris = MRISread(fname) ;
if (!mris)
ErrorExit(ERROR_NOFILE, "%s: could not read surface file %s",
Progname, fname) ;
MRISfromParameterization(mrisp, mris, 0) ;
if (area)
MRISmaskNotLabel(mris, area) ;
curvs = (n < num_class1) ? c1_thickness[n] : c2_thickness[n-num_class1] ;
class_mean = (n < num_class1) ? c1_mean : c2_mean ;
class_var = (n < num_class1) ? c1_var : c2_var ;
MRISextractCurvatureVector(mris, curvs) ;
cvector_accumulate(curvs, total_mean, nvertices) ;
cvector_accumulate(curvs, class_mean, nvertices) ;
cvector_accumulate_square(curvs, class_var, nvertices) ;
MRISPfree(&mrisp) ;
MRISfree(&mris) ;
}
}
/* compute within-group means, and total mean */
cvector_normalize(total_mean, num_class1+num_class2, nvertices) ;
cvector_normalize(c1_mean, num_class1, nvertices) ;
cvector_normalize(c2_mean, num_class2, nvertices) ;
cvector_compute_variance(c1_var, c1_mean, num_class1, nvertices) ;
cvector_compute_variance(c2_var, c2_mean, num_class2, nvertices) ;
cvector_compute_t_test(c1_mean, c1_var, c2_mean, c2_var,
num_class1, num_class2, pvals, nvertices) ;
sprintf(fname, "%s/%s/surf/%s.%s",
subjects_dir,output_subject,hemi,surf_name);
fprintf(stderr, "reading output surface %s...\n", fname) ;
mris = MRISread(fname) ;
if (!mris)
ErrorExit(ERROR_NOFILE, "%s: could not read surface file %s",
Progname, fname) ;
if (area)
MRISripNotLabel(mris, area) ;
vbest_snr = cvector_alloc(nvertices) ;
vbest_pvalues = cvector_alloc(nvertices) ;
vbest_avgs = cvector_alloc(nvertices) ;
vtotal_var = cvector_alloc(nvertices) ;
vsnr = cvector_alloc(nvertices) ;
if (read_dir == NULL) /* recompute everything */
{
if (use_buggy_snr)
cvector_multiply_variances(c1_var, c2_var, num_class1, num_class2,
vtotal_var, nvertices) ;
else
cvector_add_variances(c1_var, c2_var, num_class1, num_class2,
vtotal_var, nvertices) ;
if (use_no_distribution)
snr = cvector_compute_dist_free_snr(c1_thickness, num_class1,
c2_thickness, num_class2,
c1_mean, c2_mean,
vsnr, nvertices, &i);
else
snr = cvector_compute_snr(c1_mean, c2_mean, vtotal_var, vsnr, nvertices,
&i, 0.0f);
fprintf(stderr,
"raw SNR %2.2f, n=%2.4f, d=%2.4f, vno=%d\n",
sqrt(snr), c1_mean[i]-c2_mean[i], sqrt(vtotal_var[i]), i) ;
max_snr = snr ;
max_snr_avgs = 0 ;
cvector_track_best_snr(vsnr, vbest_snr, vbest_avgs, 0, nvertices) ;
for (n = 0 ; n < num_class1 ; n++)
cvector_copy(c1_thickness[n], c1_avg_thickness[n], nvertices) ;
for (n = 0 ; n < num_class2 ; n++)
cvector_copy(c2_thickness[n], c2_avg_thickness[n], nvertices) ;
/* now incrementally average the data, keeping track of the best
snr at each location, and at what scale it occurred. vbest_avgs
and vbest_snr will contain the scale and the snr at that scale.
*/
for (avgs = 1 ; avgs <= max_avgs ; avgs++) {
/* c?_avg_thickness is the thickness at the current scale */
if (!(avgs % 50))
fprintf(stderr, "testing %d averages...\n", avgs) ;
cvector_clear(c1_mean, nvertices) ;
cvector_clear(c2_mean, nvertices) ;
cvector_clear(c1_var, nvertices) ;
cvector_clear(c2_var, nvertices) ;
cvector_clear(total_mean, nvertices) ;
for (n = 0 ; n < num_class1 ; n++) {
MRISimportCurvatureVector(mris, c1_avg_thickness[n]) ;
MRISaverageCurvatures(mris, 1) ;
MRISextractCurvatureVector(mris, c1_avg_thickness[n]) ;
cvector_accumulate(c1_avg_thickness[n], total_mean, nvertices) ;
cvector_accumulate(c1_avg_thickness[n], c1_mean, nvertices) ;
cvector_accumulate_square(c1_avg_thickness[n], c1_var, nvertices) ;
}
for (n = 0 ; n < num_class2 ; n++) {
MRISimportCurvatureVector(mris, c2_avg_thickness[n]) ;
MRISaverageCurvatures(mris, 1) ;
MRISextractCurvatureVector(mris, c2_avg_thickness[n]) ;
cvector_accumulate(c2_avg_thickness[n], total_mean, nvertices) ;
cvector_accumulate(c2_avg_thickness[n], c2_mean, nvertices) ;
cvector_accumulate_square(c2_avg_thickness[n], c2_var, nvertices) ;
}
cvector_normalize(total_mean, num_class1+num_class2, nvertices) ;
cvector_normalize(c1_mean, num_class1, nvertices) ;
cvector_normalize(c2_mean, num_class2, nvertices) ;
cvector_compute_variance(c1_var, c1_mean, num_class1, nvertices) ;
cvector_compute_variance(c2_var, c2_mean, num_class2, nvertices) ;
if (use_buggy_snr)
cvector_multiply_variances(c1_var, c2_var, num_class1, num_class2,
vtotal_var, nvertices) ;
else
cvector_add_variances(c1_var, c2_var, num_class1, num_class2,
vtotal_var, nvertices) ;
if (use_no_distribution)
snr =
cvector_compute_dist_free_snr(c1_avg_thickness,num_class1,
c2_avg_thickness, num_class2, c1_mean,
c2_mean, vsnr, nvertices, &i);
else
snr =
cvector_compute_snr(c1_mean, c2_mean, vtotal_var, vsnr, nvertices,&i,
bonferroni ? log((double)avgs) : 0.0f);
if (write_flag && DIAG_VERBOSE_ON) {
fprintf(fp, "%d %2.1f %2.2f %2.2f %2.2f ",
avgs, sqrt((float)avgs), sqrt(snr), c1_mean[i]-c2_mean[i],
sqrt(vtotal_var[i])) ;
fflush(fp) ;
for (n = 0 ; n < num_class1 ; n++)
fprintf(fp, "%2.2f ", c1_avg_thickness[n][i]) ;
for (n = 0 ; n < num_class2 ; n++)
fprintf(fp, "%2.2f ", c2_avg_thickness[n][i]) ;
fprintf(fp, "\n") ;
fclose(fp) ;
}
if (snr > max_snr) {
fprintf(stderr,
"new max SNR found at avgs=%d (%2.1f mm)=%2.1f, n=%2.4f, "
"d=%2.4f, vno=%d\n",
avgs, sqrt((float)avgs), sqrt(snr), c1_mean[i]-c2_mean[i],
sqrt(vtotal_var[i]), i) ;
max_snr = snr ;
max_snr_avgs = avgs ;
}
cvector_track_best_snr(vsnr, vbest_snr, vbest_avgs, avgs, nvertices) ;
}
if (compute_stats)
cvector_compute_t(vbest_snr, vbest_pvalues,num_class1+num_class2,
nvertices) ;
printf("max snr=%2.2f at %d averages\n", max_snr, max_snr_avgs) ;
if (write_flag) {
MRISimportValVector(mris, vbest_snr) ;
sprintf(fname, "./%s.%s_best_snr", hemi,prefix) ;
MRISwriteValues(mris, fname) ;
MRISimportValVector(mris, vbest_avgs) ;
sprintf(fname, "./%s.%s_best_avgs", hemi, prefix) ;
MRISwriteValues(mris, fname) ;
if (compute_stats) {
MRISimportValVector(mris, vbest_pvalues) ;
sprintf(fname, "./%s.%s_best_pval", hemi,prefix) ;
MRISwriteValues(mris, fname) ;
}
}
}
else /* read from directory containing precomputed optimal values */
{
sprintf(fname, "%s/%s.%s_best_snr", read_dir, hemi, prefix) ;
if (MRISreadValues(mris, fname) != NO_ERROR)
ErrorExit(Gerror, "%s: MRISreadValues(%s) failed",Progname,fname) ;
MRISexportValVector(mris, vbest_snr) ;
sprintf(fname, "%s/%s.%s_best_avgs", read_dir, hemi, prefix) ;
if (MRISreadValues(mris, fname) != NO_ERROR)
ErrorExit(Gerror, "%s: MRISreadValues(%s) failed",Progname,fname) ;
MRISexportValVector(mris, vbest_avgs) ;
}
if (write_dir) {
sprintf(fname, "%s/%s.%s_best_snr", write_dir, hemi,prefix) ;
MRISimportValVector(mris, vbest_snr) ;
if (MRISwriteValues(mris, fname) != NO_ERROR)
ErrorExit(Gerror, "%s: MRISwriteValues(%s) failed",Progname,fname) ;
sprintf(fname, "%s/%s.%s_best_avgs", write_dir, hemi, prefix) ;
MRISimportValVector(mris, vbest_avgs) ;
if (MRISwriteValues(mris, fname) != NO_ERROR)
ErrorExit(Gerror, "%s: MRISwriteValues(%s) failed",Progname,fname) ;
}
if (nsort < -1)
nsort = mris->nvertices ;
if (nsort <= 0) {
nlabels = 0 ;
current_min_label_area = min_label_area ;
for (done = 0, current_fthresh = fthresh ;
!FZERO(current_fthresh) && !done ;
current_fthresh *= 0.95) {
int npos_labels, nneg_labels ;
LABEL **pos_labels, **neg_labels ;
for (current_min_label_area = min_label_area ;
current_min_label_area > 0.5 ;
current_min_label_area *= 0.75) {
MRISclearMarks(mris) ;
sprintf(fname, "%s-%s_thickness", hemi, prefix ? prefix : "") ;
mark_thresholded_vertices(mris, vbest_snr, vbest_avgs,current_fthresh);
segment_and_write_labels(output_subject, fname, mris,
&pos_labels, &npos_labels, 0,
current_min_label_area) ;
MRISclearMarks(mris) ;
mark_thresholded_vertices(mris, vbest_snr,vbest_avgs,-current_fthresh);
segment_and_write_labels(output_subject, fname, mris, &neg_labels,
&nneg_labels, npos_labels,
current_min_label_area) ;
nlabels = nneg_labels + npos_labels ;
if (nlabels) {
labels = (LABEL **)calloc(nlabels, sizeof(LABEL *)) ;
for (i = 0 ; i < npos_labels ; i++)
labels[i] = pos_labels[i] ;
for (i = 0 ; i < nneg_labels ; i++)
labels[i+npos_labels] = neg_labels[i] ;
free(pos_labels) ;
free(neg_labels) ;
}
done = (nlabels >= min_labels) ;
if (done) /* found enough points */
break ;
/* couldn't find enough points - free stuff and try again */
for (i = 0 ; i < nlabels ; i++)
LabelFree(&labels[i]) ;
if (nlabels)
free(labels) ;
#if 0
fprintf(stderr,"%d labels found (min %d), reducing constraints...\n",
nlabels, min_labels) ;
#endif
}
}
printf("%d labels found with F > %2.1f and area > %2.0f\n",
nlabels, current_fthresh, current_min_label_area) ;
for (i = 0 ; i < nlabels ; i++)
fprintf(stderr, "label %d: %d points, %2.1f mm\n",
i, labels[i]->n_points, LabelArea(labels[i], mris)) ;
}
/* read or compute thickness at optimal scale and put it into
c?_avg_thickness.
*/
if (!read_dir) {
fprintf(stderr, "extracting thickness at optimal scale...\n") ;
/* now build feature vectors for each subject */
extract_thickness_at_best_scale(mris, c1_avg_thickness, vbest_avgs,
c1_thickness, nvertices, num_class1);
fprintf(stderr, "extracting thickness for class 2...\n") ;
extract_thickness_at_best_scale(mris, c2_avg_thickness, vbest_avgs,
c2_thickness, nvertices, num_class2);
} else /* read in precomputed optimal thicknesses */
{
char fname[STRLEN] ;
fprintf(stderr, "reading precomputed thickness vectors\n") ;
for (n = 0 ; n < num_class1 ; n++) {
sprintf(fname, "%s/%s.%s", read_dir, hemi, argv[ARGV_OFFSET+n]) ;
fprintf(stderr, "reading thickness vector from %s...\n", fname) ;
if (MRISreadValues(mris, fname) != NO_ERROR)
ErrorExit(Gerror, "%s: could not read thickness file %s",
Progname,fname) ;
MRISexportValVector(mris, c1_avg_thickness[n]) ;
}
for (n = 0 ; n < num_class2 ; n++) {
sprintf(fname, "%s/%s.%s", read_dir, hemi,
argv[n+num_class1+1+ARGV_OFFSET]) ;
fprintf(stderr, "reading curvature vector from %s...\n", fname) ;
if (MRISreadValues(mris, fname) != NO_ERROR)
ErrorExit(Gerror, "%s: could not read thickness file %s",
Progname,fname) ;
MRISexportValVector(mris, c2_avg_thickness[n]) ;
}
}
if (write_dir) /* write out optimal thicknesses */
{
char fname[STRLEN] ;
for (n = 0 ; n < num_class1 ; n++) {
sprintf(fname, "%s/%s.%s", write_dir, hemi, argv[ARGV_OFFSET+n]) ;
fprintf(stderr, "writing curvature vector to %s...\n", fname) ;
MRISimportValVector(mris, c1_avg_thickness[n]) ;
MRISwriteValues(mris, fname) ;
}
for (n = 0 ; n < num_class2 ; n++) {
sprintf(fname, "%s/%s.%s", write_dir, hemi,
argv[n+num_class1+1+ARGV_OFFSET]) ;
fprintf(stderr, "writing curvature vector to %s...\n", fname) ;
MRISimportValVector(mris, c2_avg_thickness[n]) ;
MRISwriteValues(mris, fname) ;
}
}
/* should free c?_thickness here */
if (nsort <= 0) {
/* We have the thickness values at the most powerful scale stored for
each subject in the c1_avg_thickness and c2_avg_thickness vectors.
Now collapse them across each label and build feature vector for
classification.
*/
c1_label_thickness = (double **)calloc(num_class1, sizeof(double *)) ;
c2_label_thickness = (double **)calloc(num_class2, sizeof(double *)) ;
for (n = 0 ; n < num_class1 ; n++)
c1_label_thickness[n] = (double *)calloc(nlabels, sizeof(double)) ;
for (n = 0 ; n < num_class2 ; n++)
c2_label_thickness[n] = (double *)calloc(nlabels, sizeof(double)) ;
fprintf(stderr, "collapsing thicknesses within labels for class 1\n") ;
for (n = 0 ; n < num_class1 ; n++)
for (i = 0 ; i < nlabels ; i++)
c1_label_thickness[n][i] =
cvector_average_in_label(c1_avg_thickness[n], labels[i], nvertices) ;
fprintf(stderr, "collapsing thicknesses within labels for class 2\n") ;
for (n = 0 ; n < num_class2 ; n++)
for (i = 0 ; i < nlabels ; i++)
c2_label_thickness[n][i] =
cvector_average_in_label(c2_avg_thickness[n], labels[i], nvertices) ;
sprintf(fname, "%s_%s_class1.dat", hemi,prefix) ;
fprintf(stderr, "writing class 1 info to %s...\n", fname) ;
fp = fopen(fname, "w") ;
for (i = 0 ; i < nlabels ; i++) /* for each row */
{
for (n = 0 ; n < num_class1 ; n++) /* for each column */
fprintf(fp, "%2.2f ", c1_label_thickness[n][i]) ;
fprintf(fp, "\n") ;
}
fclose(fp) ;
sprintf(fname, "%s_%s_class2.dat", hemi,prefix) ;
fprintf(stderr, "writing class 2 info to %s...\n", fname) ;
fp = fopen(fname, "w") ;
for (i = 0 ; i < nlabels ; i++) {
for (n = 0 ; n < num_class2 ; n++)
fprintf(fp, "%2.2f ", c2_label_thickness[n][i]) ;
fprintf(fp, "\n") ;
}
fclose(fp) ;
} else {
sorted_indices = cvector_sort(vbest_snr, nvertices) ;
vno = sorted_indices[0] ;
write_vertex_data("c1.dat", vno, c1_avg_thickness,num_class1);
write_vertex_data("c2.dat", vno, c2_avg_thickness,num_class2);
printf("sorting complete\n") ;
/* re-write class means at these locations */
sprintf(fname, "%s_%s_class1.dat", hemi,prefix) ;
fprintf(stderr, "writing class 1 info to %s...\n", fname) ;
fp = fopen(fname, "w") ;
for (i = 0 ; i < nsort ; i++) {
for (n = 0 ; n < num_class1 ; n++)
fprintf(fp, "%2.2f ", c1_avg_thickness[n][sorted_indices[i]]) ;
fprintf(fp, "\n") ;
}
fclose(fp) ;
sprintf(fname, "%s_%s_class2.dat", hemi,prefix) ;
fprintf(stderr, "writing class 2 info to %s...\n", fname) ;
fp = fopen(fname, "w") ;
for (i = 0 ; i < nsort ; i++) {
for (n = 0 ; n < num_class2 ; n++)
fprintf(fp, "%2.2f ", c2_avg_thickness[n][sorted_indices[i]]) ;
fprintf(fp, "\n") ;
}
fclose(fp) ;
}
if (test_subject) {
test_thickness = cvector_alloc(nvertices) ;
test_avg_thickness = cvector_alloc(nvertices) ;
MRISfree(&mris) ;
fprintf(stderr, "reading subject %s\n", test_subject) ;
sprintf(fname, "%s/%s/surf/%s.%s",
subjects_dir,test_subject,hemi,surf_name);
mris = MRISread(fname) ;
if (!mris)
ErrorExit(ERROR_NOFILE, "%s: could not read surface file %s",
Progname, fname) ;
MRISsaveVertexPositions(mris, CANONICAL_VERTICES) ;
if (strchr(curv_name, '/') != NULL)
strcpy(fname, curv_name) ; /* full path specified */
else
sprintf(fname,"%s/%s/surf/%s.%s",
subjects_dir,test_subject,hemi,curv_name);
if (MRISreadCurvatureFile(mris, fname) != NO_ERROR)
ErrorExit(Gerror,"%s: could no read curvature file %s",Progname,fname);
mrisp = MRIStoParameterization(mris, NULL, 1, 0) ;
MRISfree(&mris) ;
sprintf(fname, "%s/%s/surf/%s.%s",
subjects_dir,output_subject,hemi,surf_name);
mris = MRISread(fname) ;
if (!mris)
ErrorExit(ERROR_NOFILE, "%s: could not read surface file %s",
Progname, fname) ;
MRISfromParameterization(mrisp, mris, 0) ;
if (area)
MRISmaskNotLabel(mris, area) ;
MRISextractCurvatureVector(mris, test_thickness) ;
for (avgs = 0 ; avgs <= max_avgs ; avgs++) {
cvector_extract_best_avg(vbest_avgs, test_thickness,test_avg_thickness,
avgs-1, nvertices) ;
MRISimportCurvatureVector(mris, test_thickness) ;
MRISaverageCurvatures(mris, 1) ;
MRISextractCurvatureVector(mris, test_thickness) ;
}
if (nsort <= 0) {
sprintf(fname, "%s_%s.dat", hemi,test_subject) ;
fprintf(stderr, "writing test subject feature vector to %s...\n",
fname) ;
fp = fopen(fname, "w") ;
for (i = 0 ; i < nlabels ; i++) /* for each row */
{
label_avg =
cvector_average_in_label(test_avg_thickness, labels[i], nvertices) ;
fprintf(fp, "%2.2f\n", label_avg) ;
}
fclose(fp) ;
} else /* use sorting instead of connected areas */
{
double classification, offset, w ;
int total_correct, total_wrong, first_wrong, vno ;
sprintf(fname, "%s_%s.dat", hemi,test_subject) ;
fprintf(stderr, "writing test subject feature vector to %s...\n",
fname) ;
fp = fopen(fname, "w") ;
first_wrong = -1 ;
total_wrong = total_correct = 0 ;
for (i = 0 ; i < nsort ; i++) {
vno = sorted_indices[i] ;
fprintf(fp, "%2.2f\n ", test_avg_thickness[sorted_indices[i]]) ;
offset = (c1_mean[vno]+c2_mean[vno])/2.0 ;
w = (c1_mean[vno]-c2_mean[vno]) ;
classification = (test_avg_thickness[vno] - offset) * w ;
if (((classification < 0) && (true_class == 1)) ||
((classification > 0) && (true_class == 2))) {
total_wrong++ ;
if (first_wrong < 0)
first_wrong = i ;
} else
total_correct++ ;
}
fclose(fp) ;
fprintf(stderr, "%d of %d correct = %2.1f%% (first wrong %d (%d)),"
"min snr=%2.1f\n",
total_correct, total_correct+total_wrong,
100.0*total_correct / (total_correct+total_wrong),
first_wrong, first_wrong >= 0 ? sorted_indices[first_wrong]:-1,
vbest_snr[sorted_indices[nsort-1]]) ;
if (first_wrong >= 0) {
write_vertex_data("c1w.dat", sorted_indices[first_wrong],
c1_avg_thickness,num_class1);
write_vertex_data("c2w.dat", sorted_indices[first_wrong],
c2_avg_thickness,num_class2);
}
}
}
msec = TimerStop(&start) ;
free(total_mean);
free(c1_mean) ;
free(c2_mean) ;
free(c1_var);
free(c2_var);
seconds = nint((float)msec/1000.0f) ;
minutes = seconds / 60 ;
seconds = seconds % 60 ;
fprintf(stderr, "classification took %d minutes and %d seconds.\n",
minutes, seconds) ;
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);
}
/*--------------------------------------------------------------------*/
static int convert_label_to_path (char* fname, char* ofname) {
LABEL* label = NULL;
int label_vno;
int num_paths;
PATH** paths = NULL;
int label_vno_test;
int path_size;
int path_index;
int pno;
int err;
/* Read the label file. */
label = LabelRead (NULL, fname);
if (NULL == label) {
ErrorReturn (ERROR_BADFILE,
(ERROR_BADFILE, "Couldn't read %s", fname));
}
/* Count the number of sentinels, -99999 vnos in the label; this is
the number of labels. */
num_paths = 0;
for (label_vno = 0; label_vno < label->n_points; label_vno++) {
if (-99999 == label->lv[label_vno].vno)
num_paths++;
}
/* Make sure we got some paths. */
if (0 == num_paths) {
LabelFree (&label);
ErrorReturn (ERROR_BADFILE,
(ERROR_BADFILE, "No encoded paths found in label file"));
}
printf ("INFO: Found %d paths in label file.\n\n", num_paths);
/* Allocate path objects. */
paths = (PATH**) calloc (num_paths, sizeof(PATH*));
if (NULL == paths) {
ErrorReturn (ERROR_NO_MEMORY,
(ERROR_NO_MEMORY, "Couldn't allocate %d paths", num_paths));
}
/* For each path we're goint o read.. */
path_index = 0;
label_vno = 0;
for (path_index = 0; path_index < num_paths; path_index++) {
/* Count the size of the path, the number of points between here
and the next sentinel. */
path_size = 0;
label_vno_test = label_vno;
while (-99999 != label->lv[label_vno_test].vno) {
path_size++;
label_vno_test++;
}
/* Make the path. */
paths[path_index] = PathAlloc (path_size, NULL);
if (NULL == paths) {
ErrorReturn (ERROR_NO_MEMORY,
(ERROR_NO_MEMORY, "Couldn't allocate path of %d points",
path_size));
}
/* Read points into the path from the label. */
pno = 0;
while (-99999 != label->lv[label_vno].vno) {
paths[path_index]->points[pno].x = label->lv[label_vno].x;
paths[path_index]->points[pno].y = label->lv[label_vno].y;
paths[path_index]->points[pno].z = label->lv[label_vno].z;
paths[path_index]->points[pno].vno = label->lv[label_vno].vno;
label_vno++;
pno++;
}
/* Now we're at the sentinel, so skip past it. */
label_vno++;
}
/* Write the path file. */
err = PathWriteMany (ofname, num_paths, paths);
if (0 != err) {
ErrorReturn (ERROR_BADFILE,
(ERROR_BADFILE, "Couldn't write to %s", ofname));
}
return (ERROR_NONE);
}
