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