int main(int argc, char *argv[]) { MRIS *mris_in,*mris_out; Progname=argv[0]; if (argc < 3) { usage_exit(-1); } mris_in=MRISread(argv[1]); mris_out=MRISextractMainComponent(mris_in,0,1,0); MRISwrite(mris_out,argv[2]); MRISfree(&mris_out); MRISfree(&mris_in); fprintf(stderr,"\ndone\n\n"); return 0; }
void MainWindow::OnFileOpen( wxCommandEvent& event ) { if (m_origSurface != NULL) { MRISfree(&m_origSurface); m_origSurface = NULL; } wxFileDialog* openDialog = new wxFileDialog(this, _("Choose a surface file to open"), m_lastLoadDir, wxEmptyString, _("All files (*)|*"), wxFD_OPEN, wxDefaultPosition); // Creates a "open file" dialog if (openDialog->ShowModal() == wxID_OK) // if the user click "Open" instead of "Cancel" { wxString filePath = openDialog->GetPath(); LoadSurface(filePath); wxFileName fileName(filePath); m_lastLoadDir = fileName.GetPath(); } // Clean up after ourselves openDialog->Destroy(); }
static int assemble_training_data_and_free_mris(MRI_SURFACE *mris[MAX_SUBJECTS], MRI *mri_overlays[MAX_SUBJECTS][MAX_OVERLAYS], int nsubjects, int noverlays, int **ptraining_classes, double ***ptraining_data, int *pntraining) { int sno, i, ntraining, *training_classes, x, y, z, f, vno, tno ; double **training_data ; for (ntraining = sno = 0 ; sno < nsubjects ; sno++) ntraining += MRISvalidVertices(mris[sno]) ; printf("%2.1fM total training voxels found\n", (float)ntraining/(1024*1024.0)) ; training_classes = (int *)calloc(ntraining, sizeof(int)) ; if (training_classes == NULL) ErrorExit(ERROR_NOFILE, "%s: could not allocate %d-len training class vector", Progname, ntraining) ; training_data = (double **)calloc(ntraining, sizeof(double *)) ; if (training_data == NULL) ErrorExit(ERROR_NOFILE, "%s: could not allocate %d-len training data vector", Progname, ntraining) ; for (tno = sno = 0 ; sno < nsubjects ; sno++) { for (vno = x = 0 ; x < mri_overlays[sno][0]->width ; x++) for (y = 0 ; y < mri_overlays[sno][0]->height ; y++) for (z = 0 ; z < mri_overlays[sno][0]->depth ; z++) for (f = 0 ; f < mri_overlays[sno][0]->nframes ; f++, vno++) { if (tno == Gdiag_no) DiagBreak() ; if (vno == Gdiag_no) DiagBreak(); if (mris[sno]->vertices[vno].ripflag) continue ; // not in cortex training_classes[tno] = mris[sno]->vertices[vno].marked ; training_data[tno] = (double *)calloc(noverlays, sizeof(double)) ; if (training_data[tno] == NULL) ErrorExit(ERROR_NOFILE, "%s: could not allocate %d-len training data vector [%d]", Progname, noverlays, tno) ; for (i = 0 ; i < noverlays ; i++) training_data[tno][i] = MRIgetVoxVal(mri_overlays[sno][i], x, y, z, f) ; tno++ ; } for (i = 0 ; i < noverlays ; i++) MRIfree(&mri_overlays[sno][i]) ; MRISfree(&mris[sno]) ; } *pntraining = ntraining ; *ptraining_classes = training_classes ; *ptraining_data = training_data ; return(NO_ERROR) ; }
int main(int argc, char *argv[]) { MRI_SURFACE *mris ; char **av, *in_fname, *out_fname ; int ac, nargs ; MRI *mri_distance ; /* rkt: check for and handle version tag */ nargs = handle_version_option (argc, argv, "$Id: mris_distance_map.c,v 1.2 2011/03/02 00:04:31 nicks Exp $", "$Name: stable5 $"); if (nargs && argc - nargs == 1) exit (0); argc -= nargs; Progname = argv[0] ; ErrorInit(NULL, NULL, NULL) ; DiagInit(NULL, NULL, NULL) ; ac = argc ; av = argv ; for ( ; argc > 1 && ISOPTION(*argv[1]) ; argc--, argv++) { nargs = get_option(argc, argv) ; argc -= nargs ; argv += nargs ; } if (argc < 3) usage_exit() ; in_fname = argv[1] ; out_fname = argv[2] ; mris = MRISread(in_fname) ; if (mris == NULL) ErrorExit(ERROR_NOFILE, "%s: could not load surface %s", Progname, out_fname) ; mri_distance = MRIScomputeDistanceMap(mris, NULL, ref_vertex_no) ; MRIwrite(mri_distance, out_fname) ; MRISfree(&mris) ; exit(0) ; return(0) ; /* for ansi */ }
int main(int argc, char *argv[]) { char **av, surf_fname[STRLEN], *template_fname, *hemi, *sphere_name, *cp, *subject, fname[STRLEN] ; int ac, nargs, ino, sno, nbad = 0, failed, n,nfields; VERTEX *v; VALS_VP *vp; MRI_SURFACE *mris ; MRI_SP *mrisp, /* *mrisp_aligned,*/ *mrisp_template ; INTEGRATION_PARMS parms ; /* rkt: check for and handle version tag */ nargs = handle_version_option (argc, argv, "$Id: mris_make_template.c,v 1.27 2011/03/02 00:04:33 nicks Exp $", "$Name: stable5 $"); if (nargs && argc - nargs == 1) exit (0); argc -= nargs; memset(&parms, 0, sizeof(parms)) ; Progname = argv[0] ; ErrorInit(NULL, NULL, NULL) ; DiagInit(NULL, NULL, NULL) ; /* setting default values for vectorial registration */ setParms(&parms); ac = argc ; av = argv ; for ( ; argc > 1 && ISOPTION(*argv[1]) ; argc--, argv++) { nargs = get_option(argc, argv,&parms) ; argc -= nargs ; argv += nargs ; } if (argc < 5) usage_exit() ; /* multiframe registration */ if (multiframes) parms.flags |= IP_USE_MULTIFRAMES; if (!strlen(subjects_dir)) /* not specified on command line*/ { cp = getenv("SUBJECTS_DIR") ; if (!cp) ErrorExit(ERROR_BADPARM, "%s: SUBJECTS_DIR not defined in environment.\n", Progname) ; strcpy(subjects_dir, cp) ; } hemi = argv[1] ; sphere_name = argv[2] ; template_fname = argv[argc-1] ; if (1 || !FileExists(template_fname)) /* first time - create it */ { fprintf(stderr, "creating new parameterization...\n") ; if (multiframes) { mrisp_template = MRISPalloc(scale, atlas_size * IMAGES_PER_SURFACE ); /* if (no_rot) /\* don't do rigid alignment *\/ */ /* mrisp_aligned = NULL ; */ /* else */ /* mrisp_aligned = MRISPalloc(scale, PARAM_FRAMES); */ } else { mrisp_template = MRISPalloc(scale, PARAM_IMAGES); /* if (no_rot) /\* don't do rigid alignment *\/ */ /* mrisp_aligned = NULL ; */ /* else */ /* mrisp_aligned = MRISPalloc(scale, PARAM_IMAGES); */ } } else { fprintf(stderr, "reading template parameterization from %s...\n", template_fname) ; /* mrisp_aligned = NULL ; */ mrisp_template = MRISPread(template_fname) ; if (!mrisp_template) ErrorExit(ERROR_NOFILE, "%s: could not open template file %s", Progname, template_fname) ; } argv += 3 ; argc -= 3 ; for (ino = 0 ; ino < argc-1 ; ino++) { failed = 0 ; subject = argv[ino] ; fprintf(stderr, "\nprocessing subject %s (%d of %d)\n", subject, ino+1, argc-1) ; sprintf(surf_fname, "%s/%s/surf/%s.%s", subjects_dir, subject, hemi, sphere_name) ; fprintf(stderr, "reading spherical surface %s...\n", surf_fname) ; mris = MRISread(surf_fname) ; if (!mris) { nbad++ ; ErrorPrintf(ERROR_NOFILE, "%s: could not read surface file %s", Progname, surf_fname) ; exit(1) ; } if (annot_name) { if (MRISreadAnnotation(mris, annot_name) != NO_ERROR) ErrorExit(ERROR_BADPARM, "%s: could not read annot file %s", Progname, annot_name) ; MRISripMedialWall(mris) ; } MRISsaveVertexPositions(mris, CANONICAL_VERTICES) ; MRIScomputeMetricProperties(mris) ; MRISstoreMetricProperties(mris) ; if (Gdiag & DIAG_WRITE) { char *cp1 ; FileNameOnly(template_fname, fname) ; cp = strchr(fname, '.') ; if (cp) { cp1 = strrchr(fname, '.') ; if (cp1 && cp1 != cp) strncpy(parms.base_name, cp+1, cp1-cp-1) ; else strcpy(parms.base_name, cp+1) ; } else strcpy(parms.base_name, "template") ; sprintf(fname, "%s.%s.out", hemi, parms.base_name); parms.fp = fopen(fname, "w") ; printf("writing output to '%s'\n", fname) ; } /* multiframe registration */ if (multiframes) { nfields=parms.nfields; for ( n = 0; n < mris->nvertices ; n++) /* allocate the VALS_VP structure */ { v=&mris->vertices[n]; vp=calloc(1,sizeof(VALS_VP)); vp->nvals=nfields; vp->orig_vals=(float*)malloc(nfields*sizeof(float)); /* before blurring */ vp->vals=(float*)malloc(nfields*sizeof(float)); /* values used by MRISintegrate */ v->vp=(void*)vp; } /* load the different fields */ for (n = 0 ; n < parms.nfields ; n++) { if (parms.fields[n].name != NULL) { sprintf(surf_fname, "%s/%s/%s/%s.%s", subjects_dir, subject, overlay_dir, hemi, parms.fields[n].name) ; printf("reading overlay file %s...\n", surf_fname) ; if (MRISreadValues(mris, surf_fname) != NO_ERROR) ErrorExit(ERROR_BADPARM, "%s: could not read overlay file %s", Progname, surf_fname) ; MRIScopyValuesToCurvature(mris) ; } else if (ReturnFieldName(parms.fields[n].field)) { /* read in precomputed curvature file */ sprintf(surf_fname, "%s/%s/surf/%s.%s", subjects_dir, subject, hemi, ReturnFieldName(parms.fields[n].field)) ; // fprintf(stderr,"\nreading field %d from %s(type=%d,frame=%d)\n",parms.fields[n].field,surf_fname,parms.fields[n].type,parms.fields[n].frame); if (MRISreadCurvatureFile(mris, surf_fname) != NO_ERROR) { fprintf(stderr,"\n\nXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX\n"); fprintf(stderr, "%s: could not read curvature file '%s'\n", Progname, surf_fname) ; failed = 1; break; } } else { /* compute curvature of surface */ sprintf(surf_fname, "%s/%s/surf/%s.%s", subjects_dir, subject, hemi, surface_names[parms.fields[n].field]) ; /*if(parms.fields[n].field==0) sprintf(fname, "inflated") ; else sprintf(fname, "smoothwm") ;*/ //fprintf(stderr,"\ngenerating field %d(type=%d,frame=%d) (from %s)\n",parms.fields[n].field,parms.fields[n].type,parms.fields[n].frame,surf_fname); // MRISsaveVertexPositions(mris, TMP_VERTICES) ; if (MRISreadVertexPositions(mris, surf_fname) != NO_ERROR) { fprintf(stderr,"\n\nXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX\n"); ErrorPrintf(ERROR_NOFILE, "%s: could not read surface file %s", Progname, surf_fname) ; fprintf(stderr,"setting up correlation coefficient to zero\n"); parms.fields[n].l_corr=parms.fields[n].l_pcorr=0.0; failed=1; break; } if (nbrs > 1) MRISsetNeighborhoodSize(mris, nbrs) ; MRIScomputeMetricProperties(mris) ; MRIScomputeSecondFundamentalForm(mris) ; MRISuseMeanCurvature(mris) ; MRISaverageCurvatures(mris, navgs) ; MRISrestoreVertexPositions(mris, CANONICAL_VERTICES) ; } /* if(parms.fields[n].field!=SULC_CORR_FRAME)*/ MRISnormalizeField(mris,parms.fields[n].type, parms.fields[n].which_norm); /* normalize values */ MRISsetCurvaturesToOrigValues(mris,n); MRISsetCurvaturesToValues(mris,n); } if (failed) { fprintf(stderr,"\n\nXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX\n"); fprintf(stderr,"Subject %s Failed",subject); fprintf(stderr,"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXX\n\n"); /* free cal structure*/ for ( n = 0; n < mris->nvertices ; n++) { v=&mris->vertices[n]; vp=(VALS_VP*)v->vp; free(vp->orig_vals); free(vp->vals); free(vp); v->vp=NULL; } /* free surface */ MRISfree(&mris); /* go onto the next subject */ continue; } } if (multiframes && (!no_rot)) { /* rigid body alignment */ parms.frame_no = 3 ; /* don't use single field correlation functions */ parms.l_corr = parms.l_pcorr = 0.0f ; parms.mrisp = MRIStoParameterization(mris, NULL, scale, 0) ; parms.mrisp_template = mrisp_template ; MRISrigidBodyAlignVectorGlobal(mris, &parms, 1.0, 64.0, 8) ; if (Gdiag & DIAG_WRITE) MRISwrite(mris, "sphere.rot.global") ; MRISrigidBodyAlignVectorLocal(mris, &parms) ; if (Gdiag & DIAG_WRITE) MRISwrite(mris, "sphere.rot.local") ; MRISPfree(&parms.mrisp) ; MRISsaveVertexPositions(mris, CANONICAL_VERTICES) ; }; if ((!multiframes) && (!no_rot) && ino > 0) { /* rigid body alignment */ sprintf(surf_fname, "%s/%s/surf/%s.%s", subjects_dir, subject, hemi, "sulc") ; if (MRISreadCurvatureFile(mris, surf_fname) != NO_ERROR) { ErrorPrintf(Gerror, "%s: could not read curvature file '%s'\n", Progname, surf_fname) ; nbad++ ; MRISfree(&mris) ; continue ; } parms.frame_no = 3 ; /* use sulc for rigid registration */ parms.mrisp = MRIStoParameterization(mris, NULL, scale, 0) ; parms.mrisp_template = mrisp_template ; parms.l_corr = 1.0f ; MRISrigidBodyAlignGlobal(mris, &parms, 1.0, 64.0, 8) ; if (Gdiag & DIAG_WRITE) MRISwrite(mris, "sphere.rot.global") ; MRISrigidBodyAlignLocal(mris, &parms) ; if (Gdiag & DIAG_WRITE) MRISwrite(mris, "sphere.rot.local") ; MRISPfree(&parms.mrisp) ; MRISsaveVertexPositions(mris, CANONICAL_VERTICES) ; } if (multiframes) { for (n = 0; n < parms.nfields ; n++) { MRISsetOrigValuesToCurvatures(mris,n); MRISaverageCurvatures(mris, parms.fields[n].navgs) ; mrisp = MRIStoParameterization(mris, NULL, scale, 0) ; MRISPcombine(mrisp, mrisp_template, parms.fields[n].frame * IMAGES_PER_SURFACE) ; MRISPfree(&mrisp) ; } /* free the VALS_VP structure */ for ( n = 0; n < mris->nvertices ; n++) { v=&mris->vertices[n]; vp=(VALS_VP*)v->vp; free(vp->orig_vals); free(vp->vals); free(vp); v->vp=NULL; } MRISfree(&mris) ; } else { for (sno = 0; sno < SURFACES ; sno++) { if (curvature_names[sno]) /* read in precomputed curvature file */ { sprintf(surf_fname, "%s/%s/surf/%s.%s", subjects_dir, subject, hemi, curvature_names[sno]) ; if (MRISreadCurvatureFile(mris, surf_fname) != NO_ERROR) { nbad++ ; ErrorPrintf(Gerror, "%s: could not read curvature file '%s'\n", Progname, surf_fname) ; failed = 1 ; break ; } /* the two next lines were not in the original code */ MRISaverageCurvatures(mris, navgs) ; MRISnormalizeCurvature(mris, which_norm) ; } else /* compute curvature of surface */ { sprintf(surf_fname, "%s/%s/surf/%s.%s", subjects_dir, subject, hemi, surface_names[sno]) ; if (MRISreadVertexPositions(mris, surf_fname) != NO_ERROR) { ErrorPrintf(ERROR_NOFILE, "%s: could not read surface file %s", Progname, surf_fname) ; nbad++ ; failed = 1 ; break ; } if (nbrs > 1) MRISsetNeighborhoodSize(mris, nbrs) ; MRIScomputeMetricProperties(mris) ; MRIScomputeSecondFundamentalForm(mris) ; MRISuseMeanCurvature(mris) ; MRISaverageCurvatures(mris, navgs) ; MRISrestoreVertexPositions(mris, CANONICAL_VERTICES) ; MRISnormalizeCurvature(mris, which_norm) ; } fprintf(stderr, "computing parameterization for surface %s...\n", surf_fname); if (failed) { continue ; MRISfree(&mris) ; } mrisp = MRIStoParameterization(mris, NULL, scale, 0) ; MRISPcombine(mrisp, mrisp_template, sno*3) ; MRISPfree(&mrisp) ; } MRISfree(&mris) ; } } #if 0 if (mrisp_aligned) /* new parameterization - use rigid alignment */ { MRI_SP *mrisp_tmp ; if (Gdiag & DIAG_WRITE) { char *cp1 ; FileNameOnly(template_fname, fname) ; cp = strchr(fname, '.') ; if (cp) { cp1 = strrchr(fname, '.') ; if (cp1 && cp1 != cp) strncpy(parms.base_name, cp+1, cp1-cp-1) ; else strcpy(parms.base_name, cp+1) ; } else strcpy(parms.base_name, "template") ; sprintf(fname, "%s.%s.out", hemi, parms.base_name); parms.fp = fopen(fname, "w") ; printf("writing output to '%s'\n", fname) ; } for (ino = 0 ; ino < argc-1 ; ino++) { subject = argv[ino] ; if (Gdiag & DIAG_WRITE) fprintf(parms.fp, "processing subject %s\n", subject) ; fprintf(stderr, "processing subject %s\n", subject) ; sprintf(surf_fname, "%s/%s/surf/%s.%s", subjects_dir, subject, hemi, sphere_name) ; fprintf(stderr, "reading spherical surface %s...\n", surf_fname) ; mris = MRISread(surf_fname) ; if (!mris) ErrorExit(ERROR_NOFILE, "%s: could not read surface file %s", Progname, surf_fname) ; MRIScomputeMetricProperties(mris) ; MRISstoreMetricProperties(mris) ; MRISsaveVertexPositions(mris, ORIGINAL_VERTICES) ; sprintf(surf_fname, "%s/%s/surf/%s.%s", subjects_dir, subject, hemi, "sulc") ; if (MRISreadCurvatureFile(mris, surf_fname) != NO_ERROR) ErrorExit(Gerror, "%s: could not read curvature file '%s'\n", Progname, surf_fname) ; parms.frame_no = 3 ; parms.mrisp = MRIStoParameterization(mris, NULL, scale, 0) ; parms.mrisp_template = mrisp_template ; parms.l_corr = 1.0f ; MRISrigidBodyAlignGlobal(mris, &parms, 1.0, 32.0, 8) ; if (Gdiag & DIAG_WRITE) MRISwrite(mris, "sphere.rot.global") ; MRISrigidBodyAlignLocal(mris, &parms) ; if (Gdiag & DIAG_WRITE) MRISwrite(mris, "sphere.rot.local") ; MRISPfree(&parms.mrisp) ; #if 0 /* write out rotated surface */ sprintf(surf_fname, "%s.rot", mris->fname) ; fprintf(stderr, "writing out rigidly aligned surface to '%s'\n", surf_fname) ; MRISwrite(mris, surf_fname) ; #endif /* now generate new parameterization using the optimal alignment */ for (sno = 0; sno < SURFACES ; sno++) { if (curvature_names[sno]) /* read in precomputed curvature file */ { sprintf(surf_fname, "%s/%s/surf/%s.%s", subjects_dir, subject, hemi, curvature_names[sno]) ; if (MRISreadCurvatureFile(mris, surf_fname) != NO_ERROR) ErrorExit(Gerror, "%s: could not read curvature file '%s'\n", Progname, surf_fname) ; } else /* compute curvature of surface */ { sprintf(surf_fname, "%s/%s/surf/%s.%s", subjects_dir, subject, hemi, surface_names[sno]) ; if (MRISreadVertexPositions(mris, surf_fname) != NO_ERROR) ErrorExit(ERROR_NOFILE, "%s: could not read surface file %s", Progname, surf_fname) ; if (nbrs > 1) MRISsetNeighborhoodSize(mris, nbrs) ; MRIScomputeMetricProperties(mris) ; MRIScomputeSecondFundamentalForm(mris) ; MRISuseMeanCurvature(mris) ; MRISaverageCurvatures(mris, navgs) ; MRISrestoreVertexPositions(mris, ORIGINAL_VERTICES) ; MRISnormalizeCurvature(mris) ; } fprintf(stderr, "computing parameterization for surface %s...\n", surf_fname); mrisp = MRIStoParameterization(mris, NULL, scale, 0) ; MRISPcombine(mrisp, mrisp_aligned, sno*3) ; MRISPfree(&mrisp) ; } MRISfree(&mris) ; } if (Gdiag & DIAG_WRITE) fclose(parms.fp) ; mrisp_tmp = mrisp_aligned ; mrisp_aligned = mrisp_template ; mrisp_template = mrisp_tmp ; MRISPfree(&mrisp_aligned) ; } #endif fprintf(stderr, "writing updated template with %d subjects to %s...\n", argc-1-nbad, template_fname) ; MRISPwrite(mrisp_template, template_fname) ; MRISPfree(&mrisp_template) ; exit(0) ; return(0) ; /* for ansi */ }
int main(int argc, char *argv[]) { tesselation_parms *parms; MRIS **mris_table, *mris,*mris_corrected; MRI *mri; char cmdline[CMD_LINE_LEN] ; make_cmd_version_string (argc, argv, "$Id: mri_mc.c,v 1.22 2011/03/02 00:04:23 nicks Exp $", "$Name: stable5 $", cmdline); Progname=argv[0]; if (argc > 1 && (stricmp(argv[1], "-d") == 0)) { downsample = atoi(argv[2]) ; argc -= 2; argv += 2 ; printf("downsampling input volume %d times\n", downsample) ; } if (argc < 4) { fprintf(stderr,"\n\nUSAGE: mri_mc input_volume " "label_value output_surface [connectivity]"); fprintf(stderr, "\noption connectivity: 1=6+,2=18,3=6,4=26 (default=1)\n\n"); exit(-1); } parms=(tesselation_parms*)calloc(1,sizeof(tesselation_parms)); if (!parms) ErrorExit(ERROR_NOMEMORY, "tesselation parms\n") ; mri=MRIread(argv[1]); if (downsample > 0) { MRI *mri_tmp ; mri_tmp = MRIdownsample2(mri, NULL) ; MRIfree(&mri) ; mri = mri_tmp ; } { MRI *mri_tmp ; mri_tmp = MRIalloc(mri->width+2, mri->height+2, mri->depth+2, mri->type) ; MRIextractInto(mri, mri_tmp, 0, 0, 0, mri->width, mri->height, mri->depth, 1, 1, 1) ; MRIfree(&mri) ; mri = mri_tmp ; } MRIreInitCache(mri); if (mri->type != MRI_UCHAR) { MRI *mri_tmp ; float min_val, max_val ; MRIvalRange(mri, &min_val, &max_val) ; if (min_val < 0 || max_val > 255) ErrorExit (ERROR_UNSUPPORTED, "%s: input volume (val range [%2.1f %2.1f]) must be " "convertible to UCHAR", Progname, min_val, max_val) ; printf("changing type of input volume to 8 bits/voxel...\n") ; mri_tmp = MRIchangeType(mri, MRI_UCHAR, 0.0, 0.999, TRUE) ; MRIfree(&mri) ; mri = mri_tmp ; } parms->mri=mri; parms->number_of_labels=1; //only one single label parms->label_values=(int*)malloc(sizeof(int)); parms->label_values[0]=atoi(argv[2]);//label; parms->ind=0; mris_table=(MRIS**)malloc(sizeof(MRIS*)); //final surface information parms->mris_table=mris_table; if ((!parms->label_values) || (!mris_table)) ErrorExit(ERROR_NOMEMORY, "labels/surfaces tables\n") ; if (argc==5) parms->connectivity=atoi(argv[4]);//connectivity; else parms->connectivity=1; initTesselationParms(parms); generateMCtesselation(parms); free(parms->label_values); mris=parms->mris_table[0]; free(parms->mris_table); freeTesselationParms(&parms); { float dist,max_e=0.0; int n,p,vn0,vn2; VERTEX *v,*vp; fprintf(stderr,"computing the maximum edge length..."); for (n = 0 ; n < mris->nvertices ; n++) { v=&mris->vertices[n]; for (p = 0 ; p < v->vnum ; p++) { vp = &mris->vertices[v->v[p]]; dist=SQR(vp->x-v->x)+SQR(vp->y-v->y)+SQR(vp->z-v->z); if (dist>max_e) max_e=dist; } } fprintf(stderr,"%f mm",sqrt(max_e)); fprintf(stderr,"\nreversing orientation of faces..."); for (n = 0 ; n < mris->nfaces ; n++) { vn0=mris->faces[n].v[0]; vn2=mris->faces[n].v[2]; /* vertex 0 becomes vertex 2 */ v=&mris->vertices[vn0]; for (p = 0 ; p < v->num ; p++) if (v->f[p]==n) v->n[p]=2; mris->faces[n].v[2]=vn0; /* vertex 2 becomes vertex 0 */ v=&mris->vertices[vn2]; for (p = 0 ; p < v->num ; p++) if (v->f[p]==n) v->n[p]=0; mris->faces[n].v[0]=vn2; } } fprintf(stderr,"\nchecking orientation of surface..."); MRISmarkOrientationChanges(mris); mris_corrected=MRISextractMainComponent(mris,0,1,0); MRISfree(&mris); fprintf(stderr,"\nwriting out surface..."); MRISaddCommandLine(mris_corrected, cmdline) ; if (mriConformed(mri) == 0) { printf("input volume is not conformed - using useRealRAS=1\n") ; mris_corrected->useRealRAS = 1 ; } // getVolGeom(mri, &mris_corrected->vg); MRISwrite(mris_corrected,argv[3]); fprintf(stderr,"done\n"); MRIfree(&mri); MRISfree(&mris_corrected); return 0; }
static int con_and_fill_pathy(char* fname, char* ofname, MRIS* mris, int seed) { int err; int num_paths; PATH **paths = NULL; LABEL *label; int *vtxnolist,*final_path, path_length, k, vtxno, nlabel, nth; /* Read the paths file. */ err = PathReadMany (fname, &num_paths, &paths); if (ERROR_NONE != err) { ErrorReturn (ERROR_BADFILE, (ERROR_BADFILE, "Couldn't read %s", fname)); } /* Warn if we have more than one path. */ if (num_paths != 1) { printf ("WARNING: Found multiple paths in paths file. \n" "Maybe you didn't mean to use the connect option?\n" "Will only convert first path\n\n"); } final_path = (int*) calloc(mris->nvertices,sizeof(int)); vtxnolist = (int*) calloc(paths[0]->n_points,sizeof(int)); for(k=0; k < paths[0]->n_points; k++) vtxnolist[k] = paths[0]->points[k].vno; printf("Finding path..."); MRISfindPath(vtxnolist, paths[0]->n_points, mris->nvertices, final_path, &path_length, mris ); // Make sure they are 0 for(k=0; k < mris->nvertices; k++) mris->vertices[k].val = 0; for(k=0; k < path_length; k++){ vtxno = final_path[k]; mris->vertices[vtxno].val = 1; } printf("Filling %d\n",seed); MRISfill(mris, seed); nlabel = 0; for(k=0; k < mris->nvertices; k++) if(mris->vertices[k].val > 0.5) nlabel++; printf("nlabel %d\n",nlabel); label = LabelAlloc(nlabel, subject, ""); label->n_points = nlabel; nth = 0; for(k=0; k < mris->nvertices; k++){ if(mris->vertices[k].val < 0.5) continue; label->lv[nth].vno = k; label->lv[nth].x = mris->vertices[k].x; label->lv[nth].y = mris->vertices[k].y; label->lv[nth].z = mris->vertices[k].z; label->lv[nth].stat = 0; nth ++; } printf("Saving label file %s\n",ofname); LabelWrite(label, ofname); PathFree(&paths[0]); free (paths); MRISfree(&mris); free(final_path); free(vtxnolist); LabelFree(&label); return(ERROR_NONE); }
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 *cp, **av, *in_fname, fname[100], path[100], name[100], hemi[100] ; int ac, nargs ; /* rkt: check for and handle version tag */ nargs = handle_version_option (argc, argv, "$Id: mris_errors.c,v 1.11 2011/03/02 00:04:31 nicks Exp $", "$Name: $"); if (nargs && argc - nargs == 1) exit (0); argc -= nargs; Progname = argv[0] ; ErrorInit(NULL, NULL, NULL) ; DiagInit(NULL, NULL, NULL) ; ac = argc ; av = argv ; for ( ; argc > 1 && ISOPTION(*argv[1]) ; argc--, argv++) { nargs = get_option(argc, argv) ; argc -= nargs ; argv += nargs ; } if (argc < 2) usage_exit() ; in_fname = argv[1] ; #if 0 out_fname = argv[2] ; cp = strrchr(out_fname, '.') ; #endif if (patch_flag) /* read in orig surface before reading in patch */ { FileNamePath(in_fname, path) ; FileNameOnly(in_fname, name) ; cp = strchr(name, '.') ; if (cp) { strncpy(hemi, cp-2, 2) ; hemi[2] = 0 ; } else strcpy(hemi, "lh") ; sprintf(fname, "%s/%s.smoothwm", path, hemi) ; mris = MRISread(fname) ; if (!mris) ErrorExit(ERROR_NOFILE, "%s: could not read surface file %s", Progname, fname) ; FileNameOnly(in_fname, name) ; MRISstoreMetricProperties(mris) ; MRISsaveVertexPositions(mris, ORIGINAL_VERTICES) ; if (MRISreadPatch(mris, name) != NO_ERROR) ErrorExit(ERROR_NOFILE, "%s: could not read patch file %s", Progname, name) ; } else { mris = MRISread(in_fname) ; if (!mris) ErrorExit(ERROR_NOFILE, "%s: could not read surface file %s", Progname, in_fname) ; MRISreadOriginalProperties(mris, "smoothwm") ; } MRISsaveVertexPositions(mris, TMP_VERTICES) ; MRISrestoreVertexPositions(mris, ORIGINAL_VERTICES) ; MRISsampleAtEachDistance(mris, nbhd_size, max_nbrs) ; MRIScomputeMetricProperties(mris) ; MRISstoreMetricProperties(mris) ; MRISrestoreVertexPositions(mris, TMP_VERTICES) ; MRIScomputeMetricProperties(mris) ; MRIScomputeDistanceErrors(mris, nbhd_size, max_nbrs) ; #if 0 if (write_flag) { MRISareaErrors(mris) ; MRISangleErrors(mris) ; } if (area_flag) { sprintf(fname, "%s.area_error", in_fname) ; printf("writing area errors to %s\n", fname) ; MRISwriteAreaError(mris, fname) ; sprintf(fname, "%s.angle_error", in_fname) ; printf("writing angle errors to %s\n", fname) ; MRISwriteAngleError(mris, fname) ; } #else sprintf(fname, "%s.distance_error", in_fname) ; fprintf(stderr, "writing errors to %s\n", fname) ; MRISwriteValues(mris, fname) ; #endif MRISfree(&mris) ; exit(0) ; return(0) ; /* for ansi */ }
int main(int argc, char *argv[]) { MRIS *mris; char *in_orig_fname=NULL, *in_seg_fname=NULL,*out_fname=NULL; MRI *mri_orig=NULL,*mri_seg=NULL,*mri_out=NULL; int nargs,n; char fname[512]; Progname=argv[0]; fprintf(stderr,"\n"); MRI_TOPOLOGY_PARMSdefault(&parms); for ( ; argc > 1 && ISOPTION(*argv[1]) ; argc--, argv++) { nargs = get_option(argc, argv) ; argc -= nargs ; argv += nargs ; } if (parms.tesselation_mode==-1) parms.tesselation_mode=parms.connectivity; if (argc<4) { fprintf(stderr, "\nUsage: %s options input_orig_file input_segmented_file output_folder\n", Progname); exit(1); }; in_orig_fname=argv[argc-3]; in_seg_fname = argv[argc-2]; out_fname = argv[argc-1]; fprintf(stderr,"************************************************************" "\nThe input orig volume is %s" "\nThe input segmented volume is %s" "\nThe output volume is %s" "\nIf this is incorrect, please exit quickly the program (Ctl-C)\n",in_orig_fname,in_seg_fname,out_fname); for (n=0;n<parms.nlabels;n++) fprintf(stderr,"label = %d: %s \n",parms.labels[n],cma_label_to_name(parms.labels[n])); if (parms.using_gca_maps) fprintf(stderr,"mixing parameters: alpha=%1.3f , beta=%1.3f \n",parms.alpha,parms.beta); else { parms.beta=1.0f; parms.alpha=1.0f; } fprintf(stderr,"connectivity = %d\n",parms.connectivity); mri_orig=MRIread(in_orig_fname); if (!mri_orig && parms.using_gca_maps) Error("orig volume: orig volume could not be read\n"); mri_seg=MRIread(in_seg_fname); if (!mri_seg) Error("segmented volume: segmented volume could not be read\n"); //check euler characteristic of initial surface if (parms.initial_surface_file) { int i,j,k,val,euler,pnvertices, pnfaces, pnedges; MRI *mri_tmp; mri_tmp=MRIclone(mri_seg,NULL); for (k=0;k<mri_seg->depth;k++) for (j=0;j<mri_seg->height;j++) for (i=0;i<mri_seg->width;i++) for (n=0;n<parms.nlabels;n++) { val=MRIgetVoxVal(mri_seg,i,j,k, 0); if (val==parms.labels[n]) { MRIsetVoxVal(mri_tmp,i,j,k,0,1); break; } } mris=MRIScreateSurfaceFromVolume(mri_tmp,1,parms.connectivity); euler=MRIScomputeEulerNumber(mris,&pnvertices,&pnfaces,&pnedges); fprintf(stderr,"\ninitial euler characteristic = %d, %d vertices, %d faces, %d edges" ,euler,pnvertices,pnfaces,pnedges); MRISwrite(mris,parms.initial_surface_file); MRISfree(&mris); MRIfree(&mri_tmp); } mri_out=MRIcorrectTopology(mri_orig,mri_seg,NULL,&parms); if (parms.nlabels == 1) { MRI *mri_tmp ; // turn off all voxels that are going to be on in the output MRImask(mri_seg, mri_out, mri_seg, 1, 0) ; /* whatever ones are left are now incorrect and should be labeled something else */ resegment_erased_voxels(mri_orig, mri_seg, mri_seg, parms.labels[0]) ; MRIreplaceValues(mri_out, mri_out, 1, parms.labels[0]) ; mri_tmp = MRIcopy(mri_seg, NULL) ; MRIcopyLabel(mri_out, mri_tmp, parms.labels[0]) ; MRIfree(&mri_out) ; mri_out = mri_tmp ; // check_volume(mri_save, mri_out, parms.labels[0]) ; } MRIwrite(mri_out,out_fname); ////TEMPORARY VALIDATION STUFF ////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////////////////////// #if 0 //validation of the algo { FILE *f; MRIS *mristb[20],*mrisr; int n,i,j,k,depth,height,width,count,count2; int tab[20]={4,43,51,12,52,13,54,18,53,17,49,10,50,11};//,6,7,10,11,12,13,17,18,43,44,45,46,49,50,51,52,53,54}; MRI *mri_val=MRIclone(parms.mri_seg,NULL); parms.nlabels=1; depth=parms.mri_seg->depth; height=parms.mri_seg->height; width=parms.mri_seg->width; for (n=0;n<14;n++) { MRIfree(&parms.mri_output); MRIfree(&parms.mri_bin); MRIfree(&parms.mri_dist); MRIfree(&parms.mri_fcost); MRIfree(&parms.mri_bcost); MRIfree(&parms.mri_fprior); MRIfree(&parms.mri_bprior); MRIfree(&parms.mri_labeled); segmentationFree(&parms.F_Bseg); segmentationFree(&parms.F_Rseg); segmentationFree(&parms.B_Bseg); segmentationFree(&parms.B_Rseg); CCSfree(&parms.F_Bccs); CCSfree(&parms.F_Rccs); CCSfree(&parms.B_Bccs); CCSfree(&parms.B_Rccs); parms.labels[0]=tab[n]; MRIcorrectTopology(parms.mri_orig,parms.mri_seg,&parms.mri_output,mris ,parms.labels,parms.nblabels,parms.f_c,parms); MRISwrite(*mris,"./tmp"); mristb[n]=MRISread("./tmp"); #if 0 count=0; count2=0; for (k=0;k<depth;k++) for (j=0;j<height;j++) for (i=0;i<width;i++) { if (MRIvox(parms.mri_seg,i,j,k)==parms.labels[0]) count2++; if (MRIvox(parms.mri_output,i,j,k)==1) { MRIvox(mri_val,i,j,k)++; if (MRIvox(parms.mri_seg,i,j,k)!=parms.labels[0]) count++; } else if (MRIvox(parms.mri_seg,i,j,k)==parms.labels[0]) count++; } fprintf(stderr,"\n yeh %d %d %f \n",count,count2,100.*count/count2); sprintf(fname,"./label%d",tab[n]); f=fopen(fname,"a+"); fprintf(f,"\n %d %d %f ",count,count2,(float)100.*count/count2); fclose(f); #endif #if 0 sprintf(fname,"./surf%d",n); MRISwrite(mristb[n],fname); MRISsmoothSurface2(mristb[n],5,0.5,0); MRISsmoothSurface2(mristb[n],5,0.25,2); MRISsmoothSurface2(mristb[n],10,0.05,5); sprintf(fname,"./surfsmooth%d",n); mristb[n]->type=MRIS_TRIANGULAR_SURFACE;//MRIS_BINARY_QUADRANGLE_FILE; MRISwrite(mristb[n],fname); MRISsetNeighborhoodSize(mristb[n],3) ; MRIScomputeMetricProperties(mristb[n]) ; MRIScomputeSecondFundamentalForm(mristb[n]) ; MRISuseMeanCurvature(mristb[n]); MRISaverageCurvatures(mristb[n],2) ; MRISnormalizeCurvature(mristb[n], NORM_MEAN) ; sprintf(fname,"./curv%d",n); MRISwriteCurvature(mristb[n],fname); #endif } #if 0 mrisr=MRISconcatenateQuadSurfaces(n,mristb); mrisr->type=MRIS_TRIANGULAR_SURFACE; MRISwrite(mrisr,"./lh.ZURFACE"); // for(k=0;k<mrisr->nvertices;k++) // mrisr->vertices[k].curv=0.3; //MRISnormalizeCurvature(mrisr, NORM_MEAN) ; MRISwriteCurvature(mrisr,"./ZURFACE_CURVATURE"); for (k=0;k<mrisr->nvertices;k++) mrisr->vertices[k].curv=mrisr->vertices[k].val; MRISwriteCurvature(mrisr,"./ZURFACE_VAL"); #endif n=0; count=0; for (k=0;k<depth;k++) for (j=0;j<height;j++) for (i=0;i<width;i++) { if (MRIgetVoxVal(mri_val,i,j,k,0)>=1) { n++; if (MRIsetVoxVal(mri_val,i,j,k,0)>1) count++; } } // sprintf(fname,"./labeltotal"); /// f=fopen(fname,"a+"); //fprintf(f,"\n %s %d %d %f ",in_seg_fname,count,n,(float)100.*count/n); //fclose(f); #if 0 MRIwrite(mri_val,"/tmp/tmp"); #endif fprintf(stderr,"\n WE HAVE %d %d %f \n",count,n,100.*count/n); } #endif ////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////// if (parms.final_surface_file) { int euler,pnvertices, pnfaces, pnedges; mris=MRIScreateSurfaceFromVolume(mri_out,1,parms.connectivity); euler=MRIScomputeEulerNumber(mris,&pnvertices,&pnfaces,&pnedges); fprintf(stderr,"\nfinal euler characteristic = %d, %d vertices, %d faces, %d edges" ,euler,pnvertices,pnfaces,pnedges); sprintf(fname,"%s",parms.final_surface_file); MRISwrite(mris,fname); #if 0 MRISsmoothSurface(mris,7,0.2); strcat(fname,"_smooth"); MRISwrite(mris,fname); if (parms.fit) { sprintf(fname,parms.surfname); strcat(fname,"_fit"); MRISmatchSurfaceToLabel(parms.mris,parms.mri_output,1,NULL,NULL,parms.f_c); MRISwrite(parms.mris,fname); } #endif MRISfree(&mris); } if (mri_out) MRIfree(&mri_out); if (mri_orig) MRIfree(&mri_orig); if (mri_seg) MRIfree(&mri_seg); fprintf(stderr,"\n"); return NO_ERROR; }
static int fill_pathx(char* fname, char* ofname, char* surfaceFname, int seed) { int err; int num_paths; PATH **paths = NULL; LABEL *label; int k, nlabel, nth; MRIS *mris; /* Read the paths file. */ err = PathReadMany (fname, &num_paths, &paths); if (ERROR_NONE != err) { ErrorReturn (ERROR_BADFILE, (ERROR_BADFILE, "Couldn't read %s", fname)); } /* Warn if we have more than one path. */ if (num_paths != 1) { printf ("WARNING: Found multiple paths in paths file. \n" "Maybe you didn't mean to use the connect option?\n" "Will only convert first path\n\n"); } printf("Reading %s\n",surfaceFname); mris = MRISread(surfaceFname); if(mris == NULL) exit(1); // Make sure vals are 0 for(k=0; k < mris->nvertices; k++) mris->vertices[k].val = 0; for(k=0; k < paths[0]->n_points; k++) mris->vertices[paths[0]->points[k].vno].val = 1; printf("Filling %d\n",seed); MRISfill(mris, seed); nlabel = 0; for(k=0; k < mris->nvertices; k++) if(mris->vertices[k].val > 0.5) nlabel++; printf("nlabel %d\n",nlabel); label = LabelAlloc(nlabel, subject, ""); label->n_points = nlabel; nth = 0; for(k=0; k < mris->nvertices; k++){ if(mris->vertices[k].val < 0.5) continue; label->lv[nth].vno = k; label->lv[nth].x = mris->vertices[k].x; label->lv[nth].y = mris->vertices[k].y; label->lv[nth].z = mris->vertices[k].z; label->lv[nth].stat = 0; nth ++; } printf("Saving label file %s\n",ofname); LabelWrite(label, ofname); PathFree(&paths[0]); free (paths); MRISfree(&mris); LabelFree(&label); return(ERROR_NONE); }
int main(int argc, char *argv[]) { char **av,*subject_fname,*subjects_fname[STRLEN],fname[STRLEN],*cp,*hemi; int ac, nargs,n , m,surface_reference,nsubjects; MRI_SURFACE *mris; MRI *mri,*mri_distance, *mri_orig; int msec, minutes, seconds ; struct timeb start; /* rkt: check for and handle version tag */ nargs = handle_version_option (argc, argv, "$Id: mris_distance_to_label.cpp,v 1.8 2011/03/02 00:04:31 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 < 3) usage_exit() ; /* hemisphere information */ hemi = argv[1]; for (nsubjects=0 , n = 2 ; n < argc ; n++) subjects_fname[nsubjects++]=argv[n]; if (nlabels==0) { fprintf(stderr,"using default option\n"); fprintf(stderr,"computing distance maps for :\n"); fprintf(stderr," amygdala\n"); fprintf(stderr," hippocampus\n"); fprintf(stderr," pallidum\n"); fprintf(stderr," putamen\n"); fprintf(stderr," caudate\n"); fprintf(stderr," lateral ventricle\n"); // fprintf(stderr," inferior lateral ventricle\n"); fprintf(stderr," layer IV gray\n"); nlabels=8; if (!stricmp(hemi,(char*)"rh")) { /* right hemisphere */ labels[0]=54; labels[1]=53; labels[2]=52; labels[3]=51; labels[4]=50; labels[5]=43; labels[6]=44; labels[7]=-1; } else { labels[0]=18; labels[1]=17; labels[2]=13; labels[3]=12; labels[4]=11; labels[5]=4; labels[6]=5; labels[7]=-1; } } for ( m = 0 ; m < nsubjects ; m++) { subject_fname=subjects_fname[m]; fprintf(stderr,"\n\nPROCESSING SUBJECT '%s' \n",subject_fname); sprintf(fname,"%s/%s/surf/%s.white", subjects_dir,subject_fname,hemi); fprintf(stderr, "reading surface from %s...\n", fname) ; mris=MRISread(fname); if (aseg_fname) sprintf(fname,"%s/%s/mri/%s", subjects_dir,subject_fname,aseg_fname); else sprintf(fname,"%s/%s/mri/aseg.mgz", subjects_dir,subject_fname); fprintf(stderr, "reading mri segmentation from %s...\n", fname) ; mri=MRIread(fname); fprintf(stderr, "allocating distance map\n") ; mri_distance=MRIalloc(mri->width,mri->height,mri->depth,MRI_FLOAT); for (n=0 ; n < nlabels ; n++) { if (labels[n]>=0) { fprintf(stderr, "generating distance map for label %d\n", labels[n]) ; MRIextractDistanceMap(mri,mri_distance,labels[n],fdistance,mode,NULL); fprintf(stderr, "extracting distance values for label %d\n", labels[n]) ; mrisExtractMRIvalues(mris,mri,mri_distance,fdistance,mode); mrisProcessDistanceValues(mris); surface_reference=findSurfaceReference(labels[n]); if (surface_reference>=3 and surface_reference<=14) sprintf(fname,"%s/%s/surf/%s.%s", subjects_dir,subject_fname,hemi, FRAME_FIELD_NAMES[surface_reference]); else sprintf(fname,"%s/%s/surf/%s.dist_%d", subjects_dir,subject_fname,hemi,labels[n]); fprintf(stderr, "writing out surface distance file for label %d in %s...\n", labels[n],fname) ; MRISaverageCurvatures(mris,navgs); MRISwriteCurvature(mris,fname); } else { /* extract layer IV */ sprintf(fname,"%s/%s/surf/%s.thickness", subjects_dir,subject_fname,hemi); fprintf(stderr, "reading curvature from %s...\n", fname) ; MRISreadCurvature(mris,fname); sprintf(fname,"%s/%s/mri/T1.mgz", subjects_dir,subject_fname); fprintf(stderr, "reading orig mri segmentation from %s...\n", fname) ; mri_orig=MRIread(fname); mrisExtractMidGrayValues(mris,mri_orig); MRIfree(&mri_orig); surface_reference=3; sprintf(fname,"%s/%s/surf/%s.%s", subjects_dir,subject_fname,hemi, FRAME_FIELD_NAMES[surface_reference]); fprintf(stderr, "writing out surface distance file for label %d in %s...\n", labels[n],fname) ; MRISaverageCurvatures(mris,navgs); MRISwriteCurvature(mris,fname); } } MRIfree(&mri_distance); MRIfree(&mri); MRISfree(&mris); } msec = TimerStop(&start) ; seconds = (int)((float)msec/1000.0f) ; minutes = seconds / 60 ; seconds = seconds % 60 ; printf("mris_distance_to_label took %d minutes and %d seconds.\n", minutes, seconds) ; exit(0) ; return(0) ; /* for ansi */ }
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 */ }
static int MRISrepositionToInnerSkull(MRI_SURFACE *mris, MRI *mri_smooth, INTEGRATION_PARMS *parms) { MRI *mri_dist, *mri_bin, *mri_kernel, *mri_bin_smooth, *mri_dist_smooth ; float l_spring, sigma ; int i, ic_order, avgs ; parms->niterations = 1000 ; if (parms->momentum < 0.0) parms->momentum = 0.0 /*0.75*/ ; mri_bin = MRIbinarize(mri_smooth, NULL, 15, 0, TARGET_VAL) ; mri_dist = MRIdistanceTransform(mri_bin, NULL, TARGET_VAL, 10*mri_bin->width, DTRANS_MODE_SIGNED, NULL) ; MRIwrite(mri_bin, "bin.mgz") ; MRIwrite(mri_dist, "dist.mgz") ; MRISscaleBrain(mris, mris, 0.5) ; // start inside mri_kernel = MRIgaussian1d(2, 0) ; mri_bin_smooth = MRIconvolveGaussian(mri_bin, NULL, mri_kernel) ; MRIwrite(mri_bin_smooth, "bin_smooth.mgz") ; MRISfindOptimalRigidPosition(mris, mri_bin_smooth, parms) ; MRIfree(&mri_kernel) ; MRIfree(&mri_bin_smooth) ; avgs = parms->n_averages = 32 ; l_spring = parms->l_spring_norm ; for (ic_order = 3 ; ic_order <= 3 ; ic_order++) { if (ic_order != ic_init) { MRI_SURFACE *mris_new ; char fname[STRLEN], *mdir ; mdir = getenv("FREESURFER_HOME") ; if (!mdir) ErrorExit(ERROR_BADPARM, "FREESURFER_HOME not defined in environment") ; sprintf(fname, "%s/lib/bem/ic%d.tri", mdir, ic_order) ; mris_new = MRISread(fname) ; MRISupsampleIco(mris, mris_new) ; MRISfree(&mris) ; mris = mris_new ; } printf("********************** using ICO order %d *********************\n", ic_order) ; parms->n_averages = avgs ; parms->l_spring_norm = l_spring ; for (sigma = 16.0, i = 0 ; i < 7 ; i++, sigma /= 2) { printf("******************** pass %d, sigma = %2.2f, avgs = %d ******************\n", i+1, sigma, parms->n_averages) ; parms->sigma = sigma ; MRISsetVals(mris,parms->sigma) ; MRIScopyValToVal2(mris) ; MRISsetVals(mris, 0) ; // 0 mm from fat parms->mri_brain = mri_dist ; mri_kernel = MRIgaussian1d(sigma, 0) ; mri_dist_smooth = MRIconvolveGaussian(mri_dist, NULL, mri_kernel) ; MRIfree(&mri_kernel) ; if (i == 0) { MRIwrite(mri_dist_smooth, "dist_smooth.mgz") ; MRISwrite(mris, "lh.0000") ; } MRISsetVals(mris, 0) ; MRISpositionSurface(mris, mri_dist, mri_dist_smooth, parms) ; parms->l_spring_norm /= 2; parms->n_averages /= 2 ; } } MRIfree(&mri_bin) ; MRIfree(&mri_dist) ; return(NO_ERROR) ; }
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[]) { char **av, *hemi, fname[STRLEN], *in_aseg_name, *out_aseg_name, *surf_dir ; int ac, nargs, h ; MRI_SURFACE *mris ; MRI *mri_aseg ; char cmdline[CMD_LINE_LEN] ; make_cmd_version_string (argc, argv, "$Id: mri_relabel_hypointensities.c,v 1.13 2015/05/15 18:44:10 nicks Exp $", "$Name: $", cmdline); /* rkt: check for and handle version tag */ nargs = handle_version_option (argc, argv, "$Id: mri_relabel_hypointensities.c,v 1.13 2015/05/15 18:44:10 nicks Exp $", "$Name: $"); if (nargs && argc - nargs == 1) { exit (0); } argc -= nargs; Progname = argv[0] ; ErrorInit(NULL, NULL, NULL) ; DiagInit(NULL, NULL, NULL) ; ac = argc ; av = argv ; for ( ; argc > 1 && ISOPTION(*argv[1]) ; argc--, argv++) { nargs = get_option(argc, argv) ; argc -= nargs ; argv += nargs ; } if (argc < 3) { usage_exit() ; } in_aseg_name = argv[1] ; surf_dir = argv[2] ; out_aseg_name = argv[3] ; mri_aseg = MRIread(in_aseg_name) ; if (!mri_aseg) { ErrorExit(ERROR_NOFILE, "%s: could not read input segmentation %s", Progname, in_aseg_name) ; } for (h = 0 ; h <= 1 ; h++) { if (h == 0) { hemi = "lh" ; } else { hemi = "rh" ; } sprintf(fname, "%s/%s.%s", surf_dir, hemi, surf_name) ; printf("reading input surface %s...\n", fname) ; mris = MRISread(fname) ; if (!mris) ErrorExit(ERROR_NOFILE, "%s: could not read surface file %s", Progname, fname) ; MRISsaveVertexPositions(mris, ORIGINAL_VERTICES) ; MRIScomputeMetricProperties(mris) ; printf("relabeling %s hypointensities...\n", hemi) ; relabel_hypointensities(mri_aseg, mris, h) ; MRISfree(&mris) ; } relabel_hypointensities_neighboring_gray(mri_aseg) ; MRIwrite(mri_aseg, out_aseg_name) ; exit(0) ; return(0) ; /* for ansi */ }
int main(int argc, char *argv[]) { char **av, *surf_name, *out_prefix, *fname; int nargs, ac, i, nsubjects, total, index; double scalar, std, tmp, maxV, minV, meanV; MRI *SrcVals[2], *AvgVals; MRI_SURFACE *BaseSurf; /* rkt: check for and handle version tag */ nargs = handle_version_option (argc, argv, "$Id: mris_diff_on_surface.c,v 1.3 2011/03/02 00:04:55 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 ; } /* command line: <surf> <datafile 1> <datafile 2> <output prefix> */ if (argc != 5) usage_exit(); surf_name = argv[1]; out_prefix = argv[argc - 1]; if (srctypestring == NULL || trgtypestring == NULL) { printf("Please specify both input and output data type!\n"); usage_exit(); } printf("Reading underlying surface file\n"); BaseSurf = MRISread(surf_name); if (!BaseSurf) ErrorExit(ERROR_NOFILE, "%s:could not read surface %s", Progname, surf_name); printf("Base surface has %d vertices\n", BaseSurf->nvertices); /* Read in the first data file */ fname = argv[2]; /* only two data types are supported */ if (!strcmp(srctypestring,"curv")) { /* curvature file */ if (MRISreadCurvatureFile(BaseSurf, fname) != 0) { printf("ERROR: reading curvature file\n"); exit(1); } SrcVals[0] = MRIcopyMRIS(NULL, BaseSurf, 0, "curv"); } else if (!strcmp(srctypestring,"paint") || !strcmp(srctypestring,"w")) { MRISreadValues(BaseSurf,fname); SrcVals[0] = MRIcopyMRIS(NULL, BaseSurf, 0, "val"); } else { printf("ERROR: unknown data file format\n"); exit(1); } if (SrcVals[0] == NULL) { fprintf(stderr, "ERROR loading data values from %s\n", fname); } /* Read in the second data file */ fname = argv[3]; /* only two data types are supported */ if (!strcmp(srctypestring,"curv")) { /* curvature file */ if (MRISreadCurvatureFile(BaseSurf, fname) != 0) { printf("ERROR: reading curvature file\n"); exit(1); } SrcVals[1] = MRIcopyMRIS(NULL, BaseSurf, 0, "curv"); } else if (!strcmp(srctypestring,"paint") || !strcmp(srctypestring,"w")) { MRISreadValues(BaseSurf,fname); SrcVals[1] = MRIcopyMRIS(NULL, BaseSurf, 0, "val"); } else { printf("ERROR: unknown data file format\n"); exit(1); } if (SrcVals[1] == NULL) { fprintf(stderr, "ERROR loading data values from %s\n", fname); } if (debugflag) { for (i=0; i < 2; i++) { printf("Data%d at vertex %d has value %g\n",i, debugvtx, MRIFseq_vox(SrcVals[i], debugvtx, 0, 0, 0)); } } #if 0 AvgVals = MRIclone(SrcVals[0], NULL); if (negflag) /* Add the two data sets */ AvgVals = MRIadd(SrcVals[0], SrcVals[1], AvgVals); else /* Data1 - Data2 */ AvgVals = MRIsubtract(SrcVals[0], SrcVals[1], AvgVals); #endif AvgVals = MRIcopy(SrcVals[0], NULL); if (negflag) { for (index=0; index < BaseSurf->nvertices; index++) { MRIFseq_vox(AvgVals, index, 0, 0, 0) = MRIFseq_vox(SrcVals[0], index, 0, 0, 0) + MRIFseq_vox(SrcVals[1], index, 0, 0, 0); } } else { for (index=0; index < BaseSurf->nvertices; index++) { MRIFseq_vox(AvgVals, index, 0, 0, 0) = MRIFseq_vox(SrcVals[0], index, 0, 0, 0) - MRIFseq_vox(SrcVals[1], index, 0, 0, 0); } } maxV = -1000.0; minV = 1000.0; meanV=0.0; for (index=0; index < BaseSurf->nvertices; index++) { scalar = MRIFseq_vox(AvgVals, index, 0, 0, 0); if (maxV < scalar) maxV = scalar; if (minV > scalar) minV = scalar; meanV += scalar; } meanV /= BaseSurf->nvertices; printf("Output max = %g, min = %g, mean = %g\n", maxV, minV, meanV); if (debugflag) { printf("Output at vertex %d has value %g\n", debugvtx, MRIFseq_vox(AvgVals, debugvtx, 0, 0, 0)); } if (pathflag) sprintf(fname, "%s", out_prefix); else { if (negflag) sprintf(fname, "%s.sum.w", out_prefix) ; else sprintf(fname, "%s.diff.w", out_prefix) ; } if (!strcmp(trgtypestring,"paint") || !strcmp(trgtypestring,"w")) { /* This function will remove a zero-valued vertices */ /* Make sense, since default value is considered as zero */ /* But it will confuse the processing with matlab! */ /* So I copy the data to the curv field to force every value is * written out */ /* MRIScopyMRI(BaseSurf, AvgVals, framesave, "val");*/ /* MRISwriteValues(BaseSurf,fname); */ MRIScopyMRI(BaseSurf, AvgVals, framesave, "curv"); MRISwriteCurvatureToWFile(BaseSurf,fname); } else { fprintf(stderr, "ERROR unknown output file format.\n"); } /* Free memories */ MRISfree(&BaseSurf); MRIfree(&AvgVals); for (i=0; i < 2; i++) { MRIfree(&SrcVals[i]); } return 0; }
int main(int argc, char *argv[]) { char **av, fname[STRLEN] ; int ac, nargs, i, j, nbins ; char *avg_subject, *cp, *hemi, *subject, *output_prefix ; int msec, minutes, seconds, nsubjects, vno ; struct timeb start ; MRI_SURFACE *mris, *mris_avg ; float ***histograms ; FILE *fp ; /* rkt: check for and handle version tag */ nargs = handle_version_option (argc, argv, "$Id: mris_surface_to_vol_distances.c,v 1.4 2011/03/02 00:04:34 nicks Exp $", "$Name: stable5 $"); if (nargs && argc - nargs == 1) exit (0); argc -= nargs; if (strlen(subjects_dir) == 0) { cp = getenv("SUBJECTS_DIR") ; if (!cp) ErrorExit(ERROR_BADPARM, "%s: SUBJECTS_DIR must be specified on the command line (-sdir) or the env", Progname) ; strcpy(subjects_dir, cp) ; } 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) ; avg_subject = argv[1] ; hemi = argv[2] ; nsubjects = argc-4 ; output_prefix = argv[argc-1] ; sprintf(fname, "%s/%s/surf/%s.sphere", subjects_dir, avg_subject, hemi) ; mris_avg = MRISread(fname) ; if (mris_avg == NULL) ErrorExit(ERROR_NOFILE, "%s: could not read spherical surface from %s", Progname, fname) ; nbins = nint(max_distance - min_distance) ; histograms = (float ***)calloc(mris_avg->nvertices, sizeof(float **)) ; if (histograms == NULL) ErrorExit(ERROR_NOMEMORY, "%s: could not allocate %d histogram pointers", Progname, mris_avg->nvertices) ; for (vno = 0 ; vno < mris_avg->nvertices ; vno++) { histograms[vno] = (float **)calloc(nbins+1, sizeof(float *)) ; if (histograms[vno] == NULL) ErrorExit(ERROR_NOMEMORY, "%s: could not allocate histogram bins %d", Progname, vno) ; for (i = 0 ; i < nbins ; i++) { histograms[vno][i] = (float *)calloc(MAX_SURFACE_SCALE*nbins+1, sizeof(float)) ; if (histograms[vno][i] == NULL) ErrorExit(ERROR_NOMEMORY, "%s: could not allocate histogram bins %d", Progname, vno) ; } } printf("processing %d subjects and writing results to %s*\n", nsubjects, output_prefix) ; for (i = 0 ; i < nsubjects ; i++) { subject = argv[i+3] ; printf("processing subject %s: %d of %d...\n", subject, i+1, nsubjects) ; sprintf(fname, "%s/%s/surf/%s.sphere.reg", subjects_dir, subject, hemi) ; mris = MRISread(fname) ; if (mris == NULL) ErrorExit(ERROR_NOFILE, "%s: could not read spherical surface from %s", Progname, fname) ; sprintf(fname, "%s/%s/surf/%s.sphere", subjects_dir, subject, hemi) ; if (MRISreadCanonicalCoordinates(mris, fname) != NO_ERROR) ErrorExit(ERROR_NOFILE, "%s: could not read spherical surface from %s", Progname, fname) ; sprintf(fname, "%s/%s/surf/%s.white", subjects_dir, subject, hemi) ; if (MRISreadOriginalProperties(mris, fname) != NO_ERROR) ErrorExit(ERROR_NOFILE, "%s: could not read white surface from %s", Progname, fname) ; if (MRISreadCurvatureFile(mris, "thickness") != NO_ERROR) ErrorExit(ERROR_NOFILE, "%s: could not read thickness file", Progname) ; mrisFindMiddleOfGray(mris) ; update_histograms(mris, mris_avg, histograms, nbins) ; MRISfree(&mris) ; } printf("writing log files with prefix %s...\n", output_prefix) ; for (vno = 0 ; vno < mris_avg->nvertices ; vno++) { sprintf(fname, "%s%7.7d.histo", output_prefix, vno) ; fp = fopen(fname, "w") ; for (i = 0 ; i < nbins ; i++) { for (j = 0 ; j < nbins*MAX_SURFACE_SCALE ; j++) { fprintf(fp, "%f ", histograms[vno][i][j]) ; } fprintf(fp, "\n") ; } fclose(fp) ; } /* compute average, store it in vertex 0 histgram, and write it out */ for (vno = 1 ; vno < mris_avg->nvertices ; vno++) { for (i = 0 ; i < nbins ; i++) for (j = 0 ; j < nbins*MAX_SURFACE_SCALE ; j++) histograms[0][i][j] += histograms[vno][i][j] ; } sprintf(fname, "%s.average.histo", output_prefix) ; fp = fopen(fname, "w") ; for (i = 0 ; i < nbins ; i++) { for (j = 0 ; j < nbins*MAX_SURFACE_SCALE ; j++) { fprintf(fp, "%f ", histograms[0][i][j]) ; } fprintf(fp, "\n") ; } fclose(fp) ; msec = TimerStop(&start) ; seconds = nint((float)msec/1000.0f) ; minutes = seconds / 60 ; seconds = seconds % 60 ; printf("distance histogram compilation took %d minutes" " and %d seconds.\n", minutes, seconds) ; exit(0) ; return(0) ; }
int main(int argc, char *argv[]) { int nargs, msec, order, i, number, vno, nnum, m, k, b1, b2, cno, flag=0, fno; struct timeb then ; MRIS *mris_in, *mris_out, *mris_high; MRI_SP *mrisp ; VERTEX *vm_out, *vm_high, *v; float s_jkm, area; Progname = argv[0] ; DiagInit(NULL, NULL, NULL) ; ErrorInit(NULL, NULL, NULL) ; for ( ; argc > 1 && ISOPTION(*argv[1]) ; argc--, argv++) { nargs = get_option(argc, argv) ; argc -= nargs ; argv += nargs ; } if (argc < 4) ErrorExit(ERROR_BADPARM, "usage: %s <input surface> <orig surface> <finest order> <output surface>", Progname); TimerStart(&then) ; order = atoi (argv[3]); fprintf(stdout, "Set %s as the finest scale level\n", argv[3]); if (order > 7) ErrorExit(ERROR_BADPARM, "the highest order is 7\n"); /*Spherical Wavelet Analysis*/ if (ANALYSIS&&!CURV) { mris_in = MRISread(argv[1]) ; if (!mris_in) ErrorExit(ERROR_NOFILE, "%s: could not read surface file %s", Progname, argv[1]) ; fprintf(stdout, "Reading input spherical surface from %s\n", argv[1]); MRISreadOriginalProperties(mris_in, argv[2]) ; fprintf(stdout, "Reading original surface from %s orig area is %f\n", argv[2],mris_in->orig_area); mris_out = ReadIcoByOrder(order, 100); for (m = 0; m<mris_out->nvertices; m++) mris_out->vertices[m].nsize=1; mrisp = MRISPalloc(1, 3); #if 1 MRIScoordsToParameterization(mris_in, mrisp, 1, ORIGINAL_VERTICES) ; MRISPblur(mrisp, mrisp, 1, 0); MRISPblur(mrisp, mrisp, 1, 1); MRISPblur(mrisp, mrisp, 1, 2); MRIScoordsFromParameterization(mrisp, mris_out) ; #else MRISreadOriginalProperties(mris_out, argv[2]) ; #endif #if 1 /*just to test if the parameterization is correct */ MRISsaveVertexPositions(mris_out, TMP_VERTICES) ; MRISrestoreVertexPositions(mris_out, ORIGINAL_VERTICES) ; MRISupdateSurface(mris_out); fprintf(stderr, "original area becomes %f\n", mris_out->total_area); center_brain(mris_out, mris_out); MRISscaleBrain(mris_out, mris_out, sqrt(100000.0f/mris_out->total_area)) ; MRISupdateSurface(mris_out); for (fno=0; fno<mris_out->nfaces; fno++) area += mris_out->faces[fno].area; fprintf(stderr, "original area becomes %f\n", area); //MRISwrite(mris_out, "/space/xrt/1/users/btquinn/buckner_paper/010223_61223/surf/lh.sampled") ; MRISsaveVertexPositions(mris_out, ORIGINAL_VERTICES) ; MRISrestoreVertexPositions(mris_out, TMP_VERTICES) ; #endif /* Initialize Ij,k*/ for (vno = 0 ; vno<mris_out->nvertices; vno++) { vm_out = &mris_out->vertices[vno]; vm_out->val = 1; } /*Iteratively compute Ij,k*/ for (i=order;i>0;i--) { mris_high = ReadIcoByOrder(i, 100); //higher order surface for (m = 0; m<mris_high->nvertices; m++) mris_high->vertices[m].nsize=1; MRISsetNeighborhoodSize(mris_high, 3) ; number = IcoNVtxsFromOrder(i-1); //the start of m vertices for (m = number; m<mris_high->nvertices; m++) { vm_out = &mris_out->vertices[m]; vm_high = &mris_high->vertices[m]; flag=0; for (nnum=0; nnum<vm_high->vnum; nnum++) if ( vm_high->v[nnum]<number ) //A(j,m) { k = vm_high->v[nnum]; v = &mris_out->vertices[k]; v->val += 0.5*vm_out->val ; } for (; nnum<vm_high->v2num; nnum++) if ( vm_high->v[nnum]<number ) //B(j,m) { k = vm_high->v[nnum]; if (flag==0) b1=k; else b2=k; flag++; v = &mris_out->vertices[k]; v->val += 0.125*vm_out->val ; } for (; nnum<vm_high->v3num; nnum++) if ( vm_high->v[nnum]<number ) //C(j,m) { k = vm_high->v[nnum]; flag=0; //C has to be a second-order neighbor of B for (cno=mris_high->vertices[b1].vnum; cno<mris_high->vertices[b1].v2num;cno++) if (mris_high->vertices[b1].v[cno]==k) flag=1; for (cno=mris_high->vertices[b2].vnum; cno<mris_high->vertices[b2].v2num;cno++) if (mris_high->vertices[b2].v[cno]==k) flag=1; if (flag) { v = &mris_out->vertices[k]; v->val -= 0.0625*vm_out->val ; } } } } /*Analysis Stage I:*/ for (i=order;i>0;i--) { mris_high = ReadIcoByOrder(i, 100); //higher order surface for (m = 0; m<mris_high->nvertices; m++) mris_high->vertices[m].nsize=1; MRISsetNeighborhoodSize(mris_high, 3) ; number = IcoNVtxsFromOrder(i-1); //the start of m vertices /* compute Yj,m for each m vertices */ for (m = number; m<mris_high->nvertices; m++) { vm_out = &mris_out->vertices[m]; vm_high = &mris_high->vertices[m]; flag=0; for (nnum=0; nnum<vm_high->vnum; nnum++) //first order neighborhood if ( vm_high->v[nnum]<number ) //neighbor A(j,m) { k = vm_high->v[nnum] ; v = &mris_out->vertices[k]; vm_out->origx -= 0.5*v->origx; vm_out->origy -= 0.5*v->origy; vm_out->origz -= 0.5*v->origz; } for (; nnum<vm_high->v2num; nnum++) //second order neighborhood if ( vm_high->v[nnum]<number ) //neighbor B(j,m) { k = vm_high->v[nnum] ; if (flag==0) b1=k; else b2=k; flag++; v = &mris_out->vertices[k]; vm_out->origx -= 0.125*v->origx; vm_out->origy -= 0.125*v->origy; vm_out->origz -= 0.125*v->origz; } for (; nnum<vm_high->v3num; nnum++) if ( vm_high->v[nnum]<number ) //neighbor C(j,m) { k = vm_high->v[nnum] ; flag=0; //C has to be a second-order neighbor of B for (cno=mris_high->vertices[b1].vnum; cno<mris_high->vertices[b1].v2num;cno++) if (mris_high->vertices[b1].v[cno]==k) flag=1; for (cno=mris_high->vertices[b2].vnum; cno<mris_high->vertices[b2].v2num;cno++) if (mris_high->vertices[b2].v[cno]==k) flag=1; if (flag) { v = &mris_out->vertices[k]; vm_out->origx += 0.0625*v->origx; vm_out->origy += 0.0625*v->origy; vm_out->origz += 0.0625*v->origz; } } } /*Analysis Stage II: */ /*Compute Lamda(j,k) using the Yita(j,m)*/ for (m = number; m<mris_high->nvertices; m++) { vm_out = &mris_out->vertices[m]; vm_high = &mris_high->vertices[m]; for (nnum=0; nnum<vm_high->vnum; nnum++) if ( vm_high->v[nnum]<number ) //A(j,m) { k = vm_high->v[nnum]; v = &mris_out->vertices[k]; s_jkm = vm_out->val/2/v->val; v->origx += s_jkm*vm_out->origx; v->origy += s_jkm*vm_out->origy; v->origz += s_jkm*vm_out->origz; } } } MRISsaveVertexPositions(mris_out, TMP_VERTICES) ; MRISrestoreVertexPositions(mris_out, ORIGINAL_VERTICES) ; #if 0 for (m=0;m<mris_out->nvertices;m++) if (mris_out->vertices[m].z>6) fprintf(stdout, "%d %f %f %f\n", m,mris_out->vertices[m].x, mris_out->vertices[m].y, mris_out->vertices[m].z); //mris_high = ReadIcoByOrder(0, 100); //for (m=0;m<mris_high->nvertices;m++) //{mris_high->vertices[m].x=mris_out->vertices[m].x; //mris_high->vertices[m].y=mris_out->vertices[m].y; //mris_high->vertices[m].z=mris_out->vertices[m].z; //} //MRISwrite(mris_high, "/space/xrt/1/users/btquinn/buckner_paper/010223_61223/surf/lh.sampled") ; #endif fprintf(stdout, "Writing wavelets coefficient of original surface to %s\n", argv[4]); MRISwrite(mris_out,argv[4] ) ; MRISrestoreVertexPositions(mris_out, TMP_VERTICES) ; MRISPfree(&mrisp) ; MRISfree(&mris_in) ; /*End of Analysis*/ } else if (ANALYSIS&&CURV) { mris_in = MRISread(argv[1]) ; if (!mris_in) ErrorExit(ERROR_NOFILE, "%s: could not read surface file %s", Progname, argv[1]) ; fprintf(stdout, "Reading input spherical surface from %s\n", argv[1]); MRISreadCurvatureFile(mris_in, argv[2]) ; fprintf(stdout, "Reading input from %s\n", argv[2]); mris_out = ReadIcoByOrder(order, 100); for (m = 0; m<mris_out->nvertices; m++) mris_out->vertices[m].nsize=1; //mrisp = MRISPalloc(1, 3); mrisp = MRIStoParameterization(mris_in, NULL, 1, 0) ; //MRISPblur(mrisp, mrisp, 1, 0); MRISfromParameterization(mrisp, mris_out, 0) ; //MRISwriteCurvature(mris_out,"/space/xrt/1/users/btquinn/buckner_paper/010223_61223/surf/lh.thickness.sampled"); /* Initialize Ij,k*/ for (vno = 0 ; vno<mris_out->nvertices; vno++) { vm_out = &mris_out->vertices[vno]; vm_out->val = 1; } /*Iteratively compute Ij,k*/ for (i=order;i>0;i--) { mris_high = ReadIcoByOrder(i, 100); //higher order surface for (m = 0; m<mris_high->nvertices; m++) mris_high->vertices[m].nsize=1; MRISsetNeighborhoodSize(mris_high, 3) ; number = IcoNVtxsFromOrder(i-1); //the start of m vertices for (m = number; m<mris_high->nvertices; m++) { vm_out = &mris_out->vertices[m]; vm_high = &mris_high->vertices[m]; flag=0; for (nnum=0; nnum<vm_high->vnum; nnum++) if ( vm_high->v[nnum]<number ) //A(j,m) { k = vm_high->v[nnum]; v = &mris_out->vertices[k]; v->val += 0.5*vm_out->val ; } for (; nnum<vm_high->v2num; nnum++) if ( vm_high->v[nnum]<number ) //B(j,m) { k = vm_high->v[nnum]; if (flag==0) b1=k; else b2=k; flag++; v = &mris_out->vertices[k]; v->val += 0.125*vm_out->val ; } for (; nnum<vm_high->v3num; nnum++) if ( vm_high->v[nnum]<number ) //C(j,m) { k = vm_high->v[nnum]; flag=0; //C has to be a second-order neighbor of B for (cno=mris_high->vertices[b1].vnum; cno<mris_high->vertices[b1].v2num;cno++) if (mris_high->vertices[b1].v[cno]==k) flag=1; for (cno=mris_high->vertices[b2].vnum; cno<mris_high->vertices[b2].v2num;cno++) if (mris_high->vertices[b2].v[cno]==k) flag=1; if (flag) { v = &mris_out->vertices[k]; v->val -= 0.0625*vm_out->val ; } } } } /*Analysis Stage I:*/ for (i=order;i>0;i--) { mris_high = ReadIcoByOrder(i, 100); //higher order surface for (m = 0; m<mris_high->nvertices; m++) mris_high->vertices[m].nsize=1; MRISsetNeighborhoodSize(mris_high, 3) ; number = IcoNVtxsFromOrder(i-1); //the start of m vertices /* compute Yj,m for each m vertices */ for (m = number; m<mris_high->nvertices; m++) { vm_out = &mris_out->vertices[m]; vm_high = &mris_high->vertices[m]; flag=0; for (nnum=0; nnum<vm_high->vnum; nnum++) //first order neighborhood if ( vm_high->v[nnum]<number ) //neighbor A(j,m) { k = vm_high->v[nnum] ; v = &mris_out->vertices[k]; vm_out->curv -= 0.5*v->curv; } for (; nnum<vm_high->v2num; nnum++) //second order neighborhood if ( vm_high->v[nnum]<number ) //neighbor B(j,m) { k = vm_high->v[nnum] ; if (flag==0) b1=k; else b2=k; flag++; v = &mris_out->vertices[k]; vm_out->curv -= 0.125*v->curv; } for (; nnum<vm_high->v3num; nnum++) if ( vm_high->v[nnum]<number ) //neighbor C(j,m) { k = vm_high->v[nnum] ; flag=0; //C has to be a second-order neighbor of B for (cno=mris_high->vertices[b1].vnum; cno<mris_high->vertices[b1].v2num;cno++) if (mris_high->vertices[b1].v[cno]==k) flag=1; for (cno=mris_high->vertices[b2].vnum; cno<mris_high->vertices[b2].v2num;cno++) if (mris_high->vertices[b2].v[cno]==k) flag=1; if (flag) { v = &mris_out->vertices[k]; vm_out->curv += 0.0625*v->curv; } } } /*Analysis Stage II: */ /*Compute Lamda(j,k) using the Yita(j,m)*/ for (m = number; m<mris_high->nvertices; m++) { vm_out = &mris_out->vertices[m]; vm_high = &mris_high->vertices[m]; for (nnum=0; nnum<vm_high->vnum; nnum++) if ( vm_high->v[nnum]<number ) //A(j,m) { k = vm_high->v[nnum]; v = &mris_out->vertices[k]; s_jkm = vm_out->val/2/v->val; v->curv += s_jkm*vm_out->curv; } } } fprintf(stdout, "Writing wavelets coefficient of original surface to %s\n", argv[4]); MRISwriteCurvature(mris_out,argv[4] ) ; MRISPfree(&mrisp) ; MRISfree(&mris_in) ; /*End of Analysis*/ } else if (SYNTHESIS) /*Spherical Wavelet Synthesis*/ { mris_out = ReadIcoByOrder(order, 100); //higher order surface fprintf(stdout, "Creating a %d order spherical surface\n", order); MRISreadOriginalProperties(mris_out, argv[1]) ; fprintf(stdout, "Reading wavelet coefficients from %s\n", argv[1]); for (m = 0; m<mris_out->nvertices; m++) mris_out->vertices[m].nsize=1; MRISsetNeighborhoodSize(mris_out, 3) ; if (COMPARE) { mris_in = MRISread(fname); for (i=1; i<IcoNVtxsFromOrder(order-1); i++) { if (mris_out->vertices[i].origx==0) area = fabs(mris_out->vertices[i].origx-mris_in->vertices[i].x); else area = fabs((mris_out->vertices[i].origx-mris_in->vertices[i].x)/mris_out->vertices[i].origx); if ( area>5 ) { mris_out->vertices[i].origx = mris_in->vertices[i].x ; fprintf(stdout, "%d %f\n", i, area); } if (mris_out->vertices[i].origy==0) area = fabs(mris_out->vertices[i].origy-mris_in->vertices[i].y); else area = fabs((mris_out->vertices[i].origy-mris_in->vertices[i].y)/mris_out->vertices[i].origy); if ( area>5 ) { mris_out->vertices[i].origy = mris_in->vertices[i].y ; fprintf(stdout, "%d %f\n", i, area); } if (mris_out->vertices[i].origz==0) area = fabs(mris_out->vertices[i].origz-mris_in->vertices[i].z); else area = fabs((mris_out->vertices[i].origz-mris_in->vertices[i].z)/mris_out->vertices[i].origz); if ( area>5 ) { mris_out->vertices[i].origz = mris_in->vertices[i].z ; fprintf(stdout, "%d %f\n", i, area); } } MRISfree(&mris_in); } fprintf(stdout, "Recover the surface using %s order coefficients\n",argv[2]); number = IcoNVtxsFromOrder(atoi(argv[2])); for (m = number; m<mris_out->nvertices; m++) { mris_out->vertices[m].origx = 0; mris_out->vertices[m].origy = 0; mris_out->vertices[m].origz = 0; } /*Initialize Ij,k*/ for (vno = 0; vno<mris_out->nvertices; vno++) { vm_out = &mris_out->vertices[vno]; vm_out->val = 1; } /*Iteratively compute Ij,k*/ for (i=order;i>0;i--) { mris_high = ReadIcoByOrder(i, 100); //higher order surface for (m = 0; m<mris_high->nvertices; m++) mris_high->vertices[m].nsize=1; MRISsetNeighborhoodSize(mris_high, 3) ; number = IcoNVtxsFromOrder(i-1); //the start of m vertices for (m = number; m<mris_high->nvertices; m++) { vm_out = &mris_out->vertices[m]; vm_high = &mris_high->vertices[m]; flag=0; for (nnum=0; nnum<vm_high->vnum; nnum++) if ( vm_high->v[nnum]<number ) //A(j,m) { k = vm_high->v[nnum]; v = &mris_out->vertices[k]; v->val += 0.5*vm_out->val ; } for (; nnum<vm_high->v2num; nnum++) if ( vm_high->v[nnum]<number ) //B(j,m) { k = vm_high->v[nnum]; if (flag==0) b1=k; else b2=k; flag++; v = &mris_out->vertices[k]; v->val += 0.125*vm_out->val ; } for (; nnum<vm_high->v3num; nnum++) if ( vm_high->v[nnum]<number ) //C(j,m) { k = vm_high->v[nnum]; flag=0; //C has to be a second-order neighbor of B for (cno=mris_high->vertices[b1].vnum; cno<mris_high->vertices[b1].v2num;cno++) if (mris_high->vertices[b1].v[cno]==k) flag=1; for (cno=mris_high->vertices[b2].vnum; cno<mris_high->vertices[b2].v2num;cno++) if (mris_high->vertices[b2].v[cno]==k) flag=1; if (flag) { v = &mris_out->vertices[k]; v->val -= 0.0625*vm_out->val ; } } } } for (i=1;i<=order;i++) { mris_high = ReadIcoByOrder(i, 100); //higher order surface for (m = 0; m<mris_high->nvertices; m++) mris_high->vertices[m].nsize=1; MRISsetNeighborhoodSize(mris_high, 3) ; number = IcoNVtxsFromOrder(i-1); //the start of m vertices /* Synthesis Stage I */ /* Compute Lamda(j+1,k) using the Yita(j,m) */ for (m = number; m<mris_high->nvertices; m++) { vm_out = &mris_out->vertices[m]; vm_high = &mris_high->vertices[m]; for (nnum=0; nnum<vm_high->vnum; nnum++) if ( vm_high->v[nnum]<number ) //A(j,m) { k = vm_high->v[nnum]; v = &mris_out->vertices[k]; s_jkm = vm_out->val/2/v->val; v->origx -= s_jkm*vm_out->origx; v->origy -= s_jkm*vm_out->origy; v->origz -= s_jkm*vm_out->origz; } } /* compute Lamda(j+1,m) for each m vertices */ for (m = number; m<mris_high->nvertices; m++) { vm_out = &mris_out->vertices[m]; vm_high = &mris_high->vertices[m]; flag=0; for (nnum=0; nnum<vm_high->vnum; nnum++) //first order neighborhood if ( vm_high->v[nnum]<number ) //neighbor A(j,m) { k = vm_high->v[nnum] ; v = &mris_out->vertices[k]; vm_out->origx += 0.5*v->origx; vm_out->origy += 0.5*v->origy; vm_out->origz += 0.5*v->origz; } for (; nnum<vm_high->v2num; nnum++) //second order neighborhood if ( vm_high->v[nnum]<number ) //neighbor B(j,m) { k = vm_high->v[nnum] ; if (flag==0) b1=k; else b2=k; flag++; v = &mris_out->vertices[k]; vm_out->origx += 0.125*v->origx; vm_out->origy += 0.125*v->origy; vm_out->origz += 0.125*v->origz; } for (; nnum<vm_high->v3num; nnum++) //third order neighborhood if ( vm_high->v[nnum]<number ) //neighbor C(j,m) { k = vm_high->v[nnum] ; flag=0; //C has to be a second-order neighbor of B for (cno=mris_high->vertices[b1].vnum; cno<mris_high->vertices[b1].v2num;cno++) if (mris_high->vertices[b1].v[cno]==k) flag=1; for (cno=mris_high->vertices[b2].vnum; cno<mris_high->vertices[b2].v2num;cno++) if (mris_high->vertices[b2].v[cno]==k) flag=1; if (flag) { v = &mris_out->vertices[k]; vm_out->origx -= 0.0625*v->origx; vm_out->origy -= 0.0625*v->origy; vm_out->origz -= 0.0625*v->origz; } } } } MRISsaveVertexPositions(mris_out, TMP_VERTICES) ; MRISrestoreVertexPositions(mris_out, ORIGINAL_VERTICES) ; fprintf(stdout, "Writing recovered surface to %s\n", argv[4]); MRISwrite(mris_out, argv[4]) ; #if 0 mris_high = ReadIcoByOrder(4, 100); for (m=0;m<mris_high->nvertices;m++) { mris_high->vertices[m].x=mris_out->vertices[m].x; mris_high->vertices[m].y=mris_out->vertices[m].y; mris_high->vertices[m].z=mris_out->vertices[m].z; } MRISwrite(mris_high, "/space/xrt/1/users/btquinn/buckner_paper/010223_61223/surf/lh.wavelet.recon") ; #endif MRISrestoreVertexPositions(mris_out, TMP_VERTICES) ; /*End of Synthesis*/ } MRISfree(&mris_out); MRISfree(&mris_high) ; msec = TimerStop(&then) ; fprintf(stdout, "spherical wavelet took %2.1f minutes\n", (float)msec/(1000.0f*60.0f)); exit(0) ; return(0) ; }
int main(int argc, char *argv[]) { char **av ; int ac, nargs, n ; MRI *mri_src, *mri_dst = NULL, *mri_bias, *mri_orig, *mri_aseg = NULL ; char *in_fname, *out_fname ; int msec, minutes, seconds ; struct timeb start ; char cmdline[CMD_LINE_LEN] ; make_cmd_version_string (argc, argv, "$Id: mri_normalize.c,v 1.80 2012/10/16 21:38:35 nicks Exp $", "$Name: $", cmdline); /* rkt: check for and handle version tag */ nargs = handle_version_option (argc, argv, "$Id: mri_normalize.c,v 1.80 2012/10/16 21:38:35 nicks Exp $", "$Name: $"); if (nargs && argc - nargs == 1) { exit (0); } argc -= nargs; Progname = argv[0] ; ErrorInit(NULL, NULL, NULL) ; DiagInit(NULL, NULL, NULL) ; mni.max_gradient = MAX_GRADIENT ; ac = argc ; av = argv ; for ( ; argc > 1 && ISOPTION(*argv[1]) ; argc--, argv++) { nargs = get_option(argc, argv) ; argc -= nargs ; argv += nargs ; } if (argc < 3) { usage_exit(0) ; } if (argc < 1) { ErrorExit(ERROR_BADPARM, "%s: no input name specified", Progname) ; } in_fname = argv[1] ; if (argc < 2) { ErrorExit(ERROR_BADPARM, "%s: no output name specified", Progname) ; } out_fname = argv[2] ; if(verbose) { printf( "reading from %s...\n", in_fname) ; } mri_src = MRIread(in_fname) ; if (!mri_src) ErrorExit(ERROR_NO_FILE, "%s: could not open source file %s", Progname, in_fname) ; MRIaddCommandLine(mri_src, cmdline) ; if(nsurfs > 0) { MRI_SURFACE *mris ; MRI *mri_dist=NULL, *mri_dist_sup=NULL, *mri_ctrl, *mri_dist_one ; LTA *lta= NULL ; int i ; TRANSFORM *surface_xform ; if (control_point_fname) // do one pass with only file control points first { MRI3dUseFileControlPoints(mri_src, control_point_fname) ; mri_dst = MRI3dGentleNormalize(mri_src, NULL, DEFAULT_DESIRED_WHITE_MATTER_VALUE, NULL, intensity_above, intensity_below/2,1, bias_sigma, mri_not_control); } else { mri_dst = MRIcopy(mri_src, NULL) ; } for (i = 0 ; i < nsurfs ; i++) { mris = MRISread(surface_fnames[i]) ; if (mris == NULL) ErrorExit(ERROR_NOFILE,"%s: could not surface %s", Progname,surface_fnames[i]); surface_xform = surface_xforms[i] ; TransformInvert(surface_xform, NULL) ; if (surface_xform->type == MNI_TRANSFORM_TYPE || surface_xform->type == TRANSFORM_ARRAY_TYPE || surface_xform->type == REGISTER_DAT) { lta = (LTA *)(surface_xform->xform) ; #if 0 if (invert) { VOL_GEOM vgtmp; LT *lt; MATRIX *m_tmp = lta->xforms[0].m_L ; lta->xforms[0].m_L = MatrixInverse(lta->xforms[0].m_L, NULL) ; MatrixFree(&m_tmp) ; lt = <a->xforms[0]; if (lt->dst.valid == 0 || lt->src.valid == 0) { printf( "WARNING:***************************************************************\n"); printf( "WARNING:dst volume infor is invalid. Most likely produce wrong inverse.\n"); printf( "WARNING:***************************************************************\n"); } copyVolGeom(<->dst, &vgtmp); copyVolGeom(<->src, <->dst); copyVolGeom(&vgtmp, <->src); } #endif } if (stricmp(surface_xform_fnames[i], "identity.nofile") != 0) { MRIStransform(mris, NULL, surface_xform, NULL) ; } mri_dist_one = MRIcloneDifferentType(mri_dst, MRI_FLOAT) ; printf("computing distance transform\n") ; MRIScomputeDistanceToSurface(mris, mri_dist_one, mri_dist_one->xsize) ; if (i == 0) { mri_dist = MRIcopy(mri_dist_one, NULL) ; } else { MRIcombineDistanceTransforms(mri_dist_one, mri_dist, mri_dist) ; } // MRIminAbs(mri_dist_one, mri_dist, mri_dist) ; MRIfree(&mri_dist_one) ; } MRIscalarMul(mri_dist, mri_dist, -1) ; if (nonmax_suppress) { printf("computing nonmaximum suppression\n") ; mri_dist_sup = MRInonMaxSuppress(mri_dist, NULL, 0, 1) ; mri_ctrl = MRIcloneDifferentType(mri_dist_sup, MRI_UCHAR) ; MRIbinarize(mri_dist_sup, mri_ctrl, min_dist, CONTROL_NONE, CONTROL_MARKED) ; } else if (erode) { int i ; mri_ctrl = MRIcloneDifferentType(mri_dist, MRI_UCHAR) ; MRIbinarize(mri_dist, mri_ctrl, min_dist, CONTROL_NONE, CONTROL_MARKED) ; for (i = 0 ; i < erode ; i++) { MRIerode(mri_ctrl, mri_ctrl) ; } } else { mri_ctrl = MRIcloneDifferentType(mri_dist, MRI_UCHAR) ; MRIbinarize(mri_dist, mri_ctrl, min_dist, CONTROL_NONE, CONTROL_MARKED) ; } if (control_point_fname) { MRInormAddFileControlPoints(mri_ctrl, CONTROL_MARKED) ; } if (mask_sigma > 0) { MRI *mri_smooth, *mri_mag, *mri_grad ; mri_smooth = MRIgaussianSmooth(mri_dst, mask_sigma, 1, NULL) ; mri_mag = MRIcloneDifferentType(mri_dst, MRI_FLOAT) ; mri_grad = MRIsobel(mri_smooth, NULL, mri_mag) ; MRIbinarize(mri_mag, mri_mag, mask_thresh, 1, 0) ; MRImask(mri_ctrl, mri_mag, mri_ctrl, 0, CONTROL_NONE) ; MRIfree(&mri_grad) ; MRIfree(&mri_mag) ; MRIfree(&mri_smooth) ; } if (mask_orig_fname) { MRI *mri_orig ; mri_orig = MRIread(mask_orig_fname) ; MRIbinarize(mri_orig, mri_orig, mask_orig_thresh, 0, 1) ; MRImask(mri_ctrl, mri_orig, mri_ctrl, 0, CONTROL_NONE) ; MRIfree(&mri_orig) ; } if (Gdiag & DIAG_WRITE && DIAG_VERBOSE_ON) { MRIwrite(mri_dist, "d.mgz"); MRIwrite(mri_dist_sup, "dm.mgz"); MRIwrite(mri_ctrl, "c.mgz"); } MRIeraseBorderPlanes(mri_ctrl, 4) ; if (aseg_fname) { mri_aseg = MRIread(aseg_fname) ; if (mri_aseg == NULL) { ErrorExit(ERROR_NOFILE, "%s: could not load aseg from %s", Progname, aseg_fname) ; } remove_nonwm_voxels(mri_ctrl, mri_aseg, mri_ctrl) ; MRIfree(&mri_aseg) ; } else { remove_surface_outliers(mri_ctrl, mri_dist, mri_dst, mri_ctrl) ; } mri_bias = MRIbuildBiasImage(mri_dst, mri_ctrl, NULL, 0.0) ; if (mri_dist) { MRIfree(&mri_dist) ; } if (mri_dist_sup) { MRIfree(&mri_dist_sup) ; } if (bias_sigma> 0) { MRI *mri_kernel = MRIgaussian1d(bias_sigma, -1) ; if (Gdiag & DIAG_WRITE && DIAG_VERBOSE_ON) { MRIwrite(mri_bias, "b.mgz") ; } printf("smoothing bias field\n") ; MRIconvolveGaussian(mri_bias, mri_bias, mri_kernel) ; if (Gdiag & DIAG_WRITE && DIAG_VERBOSE_ON) { MRIwrite(mri_bias, "bs.mgz") ; } MRIfree(&mri_kernel); } MRIfree(&mri_ctrl) ; mri_dst = MRIapplyBiasCorrectionSameGeometry (mri_dst, mri_bias, mri_dst, DEFAULT_DESIRED_WHITE_MATTER_VALUE) ; printf("writing normalized volume to %s\n", out_fname) ; MRIwrite(mri_dst, out_fname) ; exit(0) ; } // end if(surface_fname) if (!mriConformed(mri_src) && conform > 0) { printf("unconformed source detected - conforming...\n") ; mri_src = MRIconform(mri_src) ; } if (mask_fname) { MRI *mri_mask ; mri_mask = MRIread(mask_fname) ; if (!mri_mask) ErrorExit(ERROR_NOFILE, "%s: could not open mask volume %s.\n", Progname, mask_fname) ; MRImask(mri_src, mri_mask, mri_src, 0, 0) ; MRIfree(&mri_mask) ; } if (read_flag) { MRI *mri_ctrl ; double scale ; mri_bias = MRIread(bias_volume_fname) ; if (!mri_bias) ErrorExit (ERROR_BADPARM, "%s: could not read bias volume %s", Progname, bias_volume_fname) ; mri_ctrl = MRIread(control_volume_fname) ; if (!mri_ctrl) ErrorExit (ERROR_BADPARM, "%s: could not read control volume %s", Progname, control_volume_fname) ; MRIbinarize(mri_ctrl, mri_ctrl, 1, 0, 128) ; mri_dst = MRImultiply(mri_bias, mri_src, NULL) ; scale = MRImeanInLabel(mri_dst, mri_ctrl, 128) ; printf("mean in wm is %2.0f, scaling by %2.2f\n", scale, 110/scale) ; scale = 110/scale ; MRIscalarMul(mri_dst, mri_dst, scale) ; MRIwrite(mri_dst, out_fname) ; exit(0) ; } if(long_flag) { MRI *mri_ctrl ; double scale ; mri_bias = MRIread(long_bias_volume_fname) ; if (!mri_bias) ErrorExit (ERROR_BADPARM, "%s: could not read bias volume %s", Progname, long_bias_volume_fname) ; mri_ctrl = MRIread(long_control_volume_fname) ; if (!mri_ctrl) ErrorExit (ERROR_BADPARM, "%s: could not read control volume %s", Progname, long_control_volume_fname) ; MRIbinarize(mri_ctrl, mri_ctrl, 1, 0, CONTROL_MARKED) ; if (mri_ctrl->type != MRI_UCHAR) { MRI *mri_tmp ; mri_tmp = MRIchangeType(mri_ctrl, MRI_UCHAR, 0, 1,1); MRIfree(&mri_ctrl) ; mri_ctrl = mri_tmp ; } scale = MRImeanInLabel(mri_src, mri_ctrl, CONTROL_MARKED) ; printf("mean in wm is %2.0f, scaling by %2.2f\n", scale, 110/scale) ; scale = DEFAULT_DESIRED_WHITE_MATTER_VALUE/scale ; mri_dst = MRIscalarMul(mri_src, NULL, scale) ; MRIremoveWMOutliers(mri_dst, mri_ctrl, mri_ctrl, intensity_below/2) ; mri_bias = MRIbuildBiasImage(mri_dst, mri_ctrl, NULL, 0.0) ; MRIsoapBubble(mri_bias, mri_ctrl, mri_bias, 50, 1) ; MRIapplyBiasCorrectionSameGeometry(mri_dst, mri_bias, mri_dst, DEFAULT_DESIRED_WHITE_MATTER_VALUE); // MRIwrite(mri_dst, out_fname) ; // exit(0) ; } // end if(long_flag) if (grad_thresh > 0) { float thresh ; MRI *mri_mag, *mri_grad, *mri_smooth ; MRI *mri_kernel = MRIgaussian1d(.5, -1) ; mri_not_control = MRIcloneDifferentType(mri_src, MRI_UCHAR) ; switch (scan_type) { case MRI_MGH_MPRAGE: thresh = 15 ; break ; case MRI_WASHU_MPRAGE: thresh = 20 ; break ; case MRI_UNKNOWN: default: thresh = 12 ; break ; } mri_smooth = MRIconvolveGaussian(mri_src, NULL, mri_kernel) ; thresh = grad_thresh ; mri_mag = MRIcloneDifferentType(mri_src, MRI_FLOAT) ; mri_grad = MRIsobel(mri_smooth, NULL, mri_mag) ; MRIwrite(mri_mag, "m.mgz") ; MRIbinarize(mri_mag, mri_not_control, thresh, 0, 1) ; MRIwrite(mri_not_control, "nc.mgz") ; MRIfree(&mri_mag) ; MRIfree(&mri_grad) ; MRIfree(&mri_smooth) ; MRIfree(&mri_kernel) ; } #if 0 #if 0 if ((mri_src->type != MRI_UCHAR) || (!(mri_src->xsize == 1 && mri_src->ysize == 1 && mri_src->zsize == 1))) #else if (conform || (mri_src->type != MRI_UCHAR && conform > 0)) #endif { MRI *mri_tmp ; fprintf (stderr, "downsampling to 8 bits and scaling to isotropic voxels...\n") ; mri_tmp = MRIconform(mri_src) ; mri_src = mri_tmp ; } #endif if(aseg_fname) { printf("Reading aseg %s\n",aseg_fname); mri_aseg = MRIread(aseg_fname) ; if (mri_aseg == NULL) ErrorExit (ERROR_NOFILE, "%s: could not read aseg from file %s", Progname, aseg_fname) ; if (!mriConformed(mri_aseg)) { ErrorExit(ERROR_UNSUPPORTED, "%s: aseg volume %s must be conformed", Progname, aseg_fname) ; } } else { mri_aseg = NULL ; } if(verbose) { printf( "normalizing image...\n") ; } fflush(stdout); fflush(stderr); TimerStart(&start) ; if (control_point_fname) { MRI3dUseFileControlPoints(mri_src, control_point_fname) ; } // this just setup writing control-point volume saving if(control_volume_fname) { MRI3dWriteControlPoints(control_volume_fname) ; } /* first do a gentle normalization to get things in the right intensity range */ if(long_flag == 0) // if long, then this will already have been done with base control points { if(control_point_fname != NULL) /* do one pass with only file control points first */ mri_dst = MRI3dGentleNormalize(mri_src, NULL, DEFAULT_DESIRED_WHITE_MATTER_VALUE, NULL, intensity_above, intensity_below/2,1, bias_sigma, mri_not_control); else { mri_dst = MRIcopy(mri_src, NULL) ; } } fflush(stdout); fflush(stderr); if(mri_aseg) { MRI *mri_ctrl, *mri_bias ; int i ; printf("processing with aseg\n"); mri_ctrl = MRIclone(mri_aseg, NULL) ; for (i = 0 ; i < NWM_LABELS ; i++) { MRIcopyLabel(mri_aseg, mri_ctrl, aseg_wm_labels[i]) ; } printf("removing outliers in the aseg WM...\n") ; MRIremoveWMOutliersAndRetainMedialSurface(mri_dst, mri_ctrl, mri_ctrl, intensity_below) ; MRIbinarize(mri_ctrl, mri_ctrl, 1, CONTROL_NONE, CONTROL_MARKED) ; MRInormAddFileControlPoints(mri_ctrl, CONTROL_MARKED) ; if (interior_fname1) { MRIS *mris_interior1, *mris_interior2 ; mris_interior1 = MRISread(interior_fname1) ; if (mris_interior1 == NULL) ErrorExit(ERROR_NOFILE, "%s: could not read white matter surface from %s\n", Progname, interior_fname1) ; mris_interior2 = MRISread(interior_fname2) ; if (mris_interior2 == NULL) ErrorExit(ERROR_NOFILE, "%s: could not read white matter surface from %s\n", Progname, interior_fname2) ; add_interior_points(mri_ctrl, mri_dst, intensity_above, 1.25*intensity_below, mris_interior1, mris_interior2, mri_aseg, mri_ctrl) ; MRISfree(&mris_interior1) ; MRISfree(&mris_interior2) ; } if (Gdiag & DIAG_WRITE && DIAG_VERBOSE_ON) { MRIwrite(mri_ctrl, "norm_ctrl.mgz") ; } printf("Building bias image\n"); fflush(stdout); fflush(stderr); mri_bias = MRIbuildBiasImage(mri_dst, mri_ctrl, NULL, 0.0) ; fflush(stdout); fflush(stderr); if (bias_sigma> 0) { printf("Smoothing with sigma %g\n",bias_sigma); MRI *mri_kernel = MRIgaussian1d(bias_sigma, -1) ; MRIconvolveGaussian(mri_bias, mri_bias, mri_kernel) ; MRIfree(&mri_kernel); fflush(stdout); fflush(stderr); } MRIfree(&mri_ctrl) ; MRIfree(&mri_aseg) ; printf("Applying bias correction\n"); mri_dst = MRIapplyBiasCorrectionSameGeometry (mri_dst, mri_bias, mri_dst, DEFAULT_DESIRED_WHITE_MATTER_VALUE) ; if (Gdiag & DIAG_WRITE && DIAG_VERBOSE_ON) { MRIwrite(mri_dst, "norm_1.mgz") ; } fflush(stdout); fflush(stderr); } // if(mri_aseg) else { printf("processing without aseg, no1d=%d\n",no1d); if (!no1d) { printf("MRInormInit(): \n"); MRInormInit(mri_src, &mni, 0, 0, 0, 0, 0.0f) ; printf("MRInormalize(): \n"); mri_dst = MRInormalize(mri_src, NULL, &mni) ; if (!mri_dst) { no1d = 1 ; printf("1d normalization failed - trying no1d...\n") ; // ErrorExit(ERROR_BADPARM, "%s: normalization failed", Progname) ; } } if(no1d) { if ((file_only && nosnr) || ((gentle_flag != 0) && (control_point_fname != NULL))) { if (mri_dst == NULL) { mri_dst = MRIcopy(mri_src, NULL) ; } } else { if (nosnr) { if (interior_fname1) { MRIS *mris_interior1, *mris_interior2 ; MRI *mri_ctrl ; printf("computing initial normalization using surface interiors\n"); mri_ctrl = MRIcloneDifferentType(mri_src, MRI_UCHAR) ; mris_interior1 = MRISread(interior_fname1) ; if (mris_interior1 == NULL) ErrorExit(ERROR_NOFILE, "%s: could not read white matter surface from %s\n", Progname, interior_fname1) ; mris_interior2 = MRISread(interior_fname2) ; if (mris_interior2 == NULL) ErrorExit(ERROR_NOFILE, "%s: could not read white matter surface from %s\n", Progname, interior_fname2) ; add_interior_points(mri_ctrl, mri_dst, intensity_above, 1.25*intensity_below, mris_interior1, mris_interior2, mri_aseg, mri_ctrl) ; MRISfree(&mris_interior1) ; MRISfree(&mris_interior2) ; mri_bias = MRIbuildBiasImage(mri_dst, mri_ctrl, NULL, 0.0) ; if (bias_sigma> 0) { MRI *mri_kernel = MRIgaussian1d(bias_sigma, -1) ; MRIconvolveGaussian(mri_bias, mri_bias, mri_kernel) ; MRIfree(&mri_kernel); } mri_dst = MRIapplyBiasCorrectionSameGeometry (mri_src, mri_bias, mri_dst, DEFAULT_DESIRED_WHITE_MATTER_VALUE) ; MRIfree(&mri_ctrl) ; } else if (long_flag == 0) // no initial normalization specified { mri_dst = MRIcopy(mri_src, NULL) ; } } else { printf("computing initial normalization using SNR...\n") ; mri_dst = MRInormalizeHighSignalLowStd (mri_src, mri_dst, bias_sigma, DEFAULT_DESIRED_WHITE_MATTER_VALUE) ; } } if (!mri_dst) ErrorExit (ERROR_BADPARM, "%s: could not allocate volume", Progname) ; } } // else (not using aseg) fflush(stdout); fflush(stderr); if (file_only == 0) MRI3dGentleNormalize(mri_dst, NULL, DEFAULT_DESIRED_WHITE_MATTER_VALUE, mri_dst, intensity_above, intensity_below/2, file_only, bias_sigma, mri_not_control); mri_orig = MRIcopy(mri_dst, NULL) ; printf("\n"); printf("Iterating %d times\n",num_3d_iter); for (n = 0 ; n < num_3d_iter ; n++) { if(file_only) { break ; } printf( "---------------------------------\n"); printf( "3d normalization pass %d of %d\n", n+1, num_3d_iter) ; if (gentle_flag) MRI3dGentleNormalize(mri_dst, NULL, DEFAULT_DESIRED_WHITE_MATTER_VALUE, mri_dst, intensity_above/2, intensity_below/2, file_only, bias_sigma, mri_not_control); else MRI3dNormalize(mri_orig, mri_dst, DEFAULT_DESIRED_WHITE_MATTER_VALUE, mri_dst, intensity_above, intensity_below, file_only, prune, bias_sigma, scan_type, mri_not_control); } printf( "Done iterating ---------------------------------\n"); // this just setup writing control-point volume saving if(control_volume_fname) { MRI3dWriteControlPoints(control_volume_fname) ; } if(bias_volume_fname) { mri_bias = compute_bias(mri_src, mri_dst, NULL) ; printf("writing bias field to %s....\n", bias_volume_fname) ; MRIwrite(mri_bias, bias_volume_fname) ; MRIfree(&mri_bias) ; } if (verbose) { printf("writing output to %s\n", out_fname) ; } MRIwrite(mri_dst, out_fname) ; msec = TimerStop(&start) ; MRIfree(&mri_src); MRIfree(&mri_dst); seconds = nint((float)msec/1000.0f) ; minutes = seconds / 60 ; seconds = seconds % 60 ; printf( "3D bias adjustment took %d minutes and %d seconds.\n", minutes, seconds) ; exit(0) ; return(0) ; }
int main(int argc, char *argv[]) { char **av, *in_fname; int ac, nargs; MRIS *mris; int msec, minutes, seconds, nv, nf, ne, eno ; struct timeb start ; double total_volume; /* rkt: check for and handle version tag */ nargs = handle_version_option (argc, argv, "$Id: mris_volume.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 (argc < 2) usage_exit(1) ; // printf("command line parsing finished\n"); /*** Read in the input surfaces ***/ in_fname = argv[1] ; if (verbose) printf("reading %s...\n", in_fname) ; mris = MRISread(in_fname) ; if(mris == NULL) ErrorExit(ERROR_NOFILE, "%s: could not read surface %s", Progname, in_fname) ; eno = MRIScomputeEulerNumber(mris, &nv, &nf, &ne) ; if (eno != 2) ErrorExit(ERROR_BADPARM, "%s: surface %s has an incorrect topology (eno=%d)", Progname, in_fname, eno) ; if(verbose) printf("surface file read in.\n"); total_volume = MRISvolumeInSurf(mris); msec = TimerStop(&start) ; seconds = nint((float)msec/1000.0f) ; minutes = seconds / 60 ; seconds = seconds % 60 ; if (verbose) printf("Volume computation took %d minutes and %d seconds.\n", minutes, seconds) ; if (verbose) printf("total volume surrounded by the surface is %g\n", total_volume); else printf("%lf\n", total_volume); MRISfree(&mris); exit(0); }
int main(int argc, char *argv[]) { char **av, surf_fname[100], *template_fname, *out_fname, *surf_dir, *hemi, *sphere_name ; int ac, nargs ; MRI_SURFACE *mris ; MRI_SP *mrisp, *mrisp_template ; /* rkt: check for and handle version tag */ nargs = handle_version_option (argc, argv, "$Id: mris_add_template.c,v 1.8 2011/03/02 00:04:26 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 < 5) usage_exit() ; surf_dir = argv[1] ; hemi = argv[2] ; sphere_name = argv[3] ; out_fname = template_fname = argv[4] ; if (argc > 5) out_fname = argv[5] ; sprintf(surf_fname, "%s/%s.%s", surf_dir, hemi, sphere_name) ; fprintf(stderr, "reading new surface %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 (!FileExists(template_fname)) /* first time - create it */ { fprintf(stderr, "creating new parameterization...\n") ; mrisp_template = MRISPalloc(scale, PARAM_IMAGES); } else { fprintf(stderr, "reading template parameterization from %s...\n", template_fname) ; mrisp_template = MRISPread(template_fname) ; if (!mrisp_template) ErrorExit(ERROR_NOFILE, "%s: could not open template file %s", Progname, template_fname) ; } /* first read in inflated surface and use it to build the first template set. */ sprintf(surf_fname, "%s/%s.%s", surf_dir, hemi, INFLATED_NAME) ; if (MRISreadVertexPositions(mris, surf_fname) != NO_ERROR) ErrorExit(ERROR_NOFILE, "%s: could not read surface file %s", Progname, surf_fname) ; MRISsetNeighborhoodSize(mris, nbrs) ; MRIScomputeMetricProperties(mris) ; MRIScomputeSecondFundamentalForm(mris) ; MRISuseMeanCurvature(mris) ; MRISaverageCurvatures(mris, navgs) ; MRISrestoreVertexPositions(mris, ORIGINAL_VERTICES) ; MRISnormalizeCurvature(mris, which_norm) ; fprintf(stderr, "computing parameterization for surface %s...\n",surf_fname); mrisp = MRIStoParameterization(mris, NULL, scale, 0) ; MRISPcombine(mrisp, mrisp_template, 0) ; MRISPfree(&mrisp) ; /* now do the same thing with the smoothwm curvatures. */ sprintf(surf_fname, "%s/%s.%s", surf_dir, hemi, SMOOTH_NAME) ; if (MRISreadVertexPositions(mris, surf_fname) != NO_ERROR) ErrorExit(ERROR_NOFILE, "%s: could not read surface file %s", Progname, surf_fname) ; MRIScomputeMetricProperties(mris) ; if (curvature_fname[0]) MRISreadCurvatureFile(mris, curvature_fname) ; else { MRIScomputeSecondFundamentalForm(mris) ; MRISuseMeanCurvature(mris) ; } MRISaverageCurvatures(mris, navgs) ; MRISrestoreVertexPositions(mris, ORIGINAL_VERTICES) ; if (curvature_fname[0]) fprintf(stderr, "computing parameterization for surface %s (%s)...\n", surf_fname, curvature_fname); else fprintf(stderr, "computing parameterization for surface %s...\n", surf_fname); MRISnormalizeCurvature(mris, which_norm) ; mrisp = MRIStoParameterization(mris, NULL, scale, 0) ; MRISPcombine(mrisp, mrisp_template, 3) ; fprintf(stderr, "writing updated template to %s...\n", out_fname) ; MRISPwrite(mrisp_template, out_fname) ; MRISPfree(&mrisp) ; MRISPfree(&mrisp_template) ; MRISfree(&mris) ; exit(0) ; return(0) ; /* for ansi */ }
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) ; }
int FCDfree(FCD_DATA **pfcd) { FCD_DATA *fcd ; fcd = *pfcd ; *pfcd = NULL ; if (fcd->mris_lh) { MRISfree(&fcd->mris_lh) ; } if (fcd->mris_rh) { MRISfree(&fcd->mris_rh) ; } if (fcd->mris_lh_pial) { MRISfree(&fcd->mris_lh_pial); } if (fcd->mris_rh_pial) { MRISfree(&fcd->mris_rh_pial); } if (fcd->mris_lh_sphere_d1) { MRISfree(&fcd->mris_lh_sphere_d1); } if (fcd->mris_rh_sphere_d1) { MRISfree(&fcd->mris_rh_sphere_d1); } if (fcd->mri_aseg) { MRIfree(&fcd->mri_aseg) ; } if (fcd->mri_aparc) { MRIfree(&fcd->mri_aparc) ; } if (fcd->mri_norm) { MRIfree(&fcd->mri_norm) ; } if (fcd->mri_flair) { MRIfree(&fcd->mri_flair) ; } if (fcd->mri_thickness_increase) { MRIfree(&fcd->mri_thickness_increase) ; } if (fcd->mri_thickness_decrease) { MRIfree(&fcd->mri_thickness_decrease) ; } if (fcd->mri_thickness_difference) { MRIfree(&fcd->mri_thickness_difference); } if (fcd->lh_thickness_on_lh) { MRIfree(&fcd->lh_thickness_on_lh) ; } if (fcd->lh_thickness_on_rh) { MRIfree(&fcd->lh_thickness_on_rh) ; } if (fcd->rh_thickness_on_lh) { MRIfree(&fcd->rh_thickness_on_lh) ; } if (fcd->rh_thickness_on_rh) { MRIfree(&fcd->rh_thickness_on_rh) ; } fcdFreeLabels(fcd) ; free(fcd) ; return(NO_ERROR) ; }
int main(int argc, char *argv[]) { char **av, *avg_surf_name, *canon_surf_name, fname[STRLEN], *mdir, ico_fname[STRLEN], *hemi, *out_sname ; int ac, nargs, i, vno, n ; VERTEX *v ; MRI_SURFACE *mris_ico ; MRI_SP *mrisp_total ; LTA *lta ; VOL_GEOM vg; float average_surface_area = 0.0 ; MATRIX *XFM=NULL; GCA_MORPH *gcam=NULL; memset((void *) &vg, 0, sizeof (VOL_GEOM)); /* rkt: check for and handle version tag */ nargs = handle_version_option (argc, argv, "$Id: mris_make_average_surface.c,v 1.29 2011/03/02 00:04:33 nicks Exp $", "$Name: stable5 $"); if (nargs && argc - nargs == 1) exit (0); argc -= nargs; Progname = argv[0] ; ErrorInit(NULL, NULL, NULL) ; DiagInit(NULL, NULL, NULL) ; mdir = getenv("FREESURFER_HOME") ; if (!mdir) ErrorExit(ERROR_BADPARM, "%s: no FREESURFER_HOME in environment.\n",Progname); ac = argc ; av = argv ; for ( ; argc > 1 && ISOPTION(*argv[1]) ; argc--, argv++) { nargs = get_option(argc, argv) ; argc -= nargs ; argv += nargs ; } if (sdir == NULL) { sdir = getenv("SUBJECTS_DIR"); if (!sdir) ErrorExit(ERROR_BADPARM, "%s: no SUBJECTS_DIR in environment.\n",Progname); } if (sdirout == NULL) sdirout = sdir; if (argc < 6) usage_exit() ; hemi = argv[1] ; avg_surf_name = argv[2] ; canon_surf_name = argv[3] ; out_sname = argv[4] ; printf("---------------------------------------------------\n"); printf("hemi = %s\n",hemi); printf("avg_surf_name = %s\n",avg_surf_name); printf("canon_surf_name = %s\n",canon_surf_name); printf("out_sname = %s\n",out_sname); printf("xform = %s\n",xform_name); printf("---------------------------------------------------\n"); printf("\n\n"); fflush(stdout); #define SCALE 1 mrisp_total = MRISPalloc(SCALE, 3) ; for (n = 0, i = 5 ; i < argc ; i++) { MRI *mri; MRI_SURFACE *mris; MRI_SP *mrisp; printf("\n---------------------------------------------------\n"); printf("#@# processing subject %d/%d %s...\n", i-4,argc-5,argv[i]) ; fflush(stdout); // read sphere.reg sprintf(fname, "%s/%s/surf/%s.%s", sdir, argv[i], hemi, canon_surf_name) ; printf(" Reading %s\n",fname); fflush(stdout); mris = MRISread(fname) ; if (!mris) { ErrorExit(ERROR_NOFILE, "%s: could not read surface file %s", Progname, fname) ; exit(1); } // get "pial" surface vertex into ->origx, origy, origz if (MRISreadOriginalProperties(mris, orig_name) != NO_ERROR) ErrorExit(ERROR_BADFILE,"%s: could not read orig file for %s.\n", Progname, argv[1]); // read transform if (0) { sprintf(fname, "%s/%s/mri/transforms/%s", sdir, argv[i], xform_name) ; lta = LTAreadEx(fname) ; if (!lta) ErrorExit(ERROR_BADPARM, "%s: could not read transform from %s", Progname, fname) ; } // read T1 volume sprintf(fname, "%s/%s/mri/T1.mgz", sdir, argv[i]) ; if (fio_FileExistsReadable(fname)) mri = MRIreadHeader(fname,MRI_MGH_FILE); else { sprintf(fname, "%s/%s/mri/T1", sdir, argv[i]) ; mri = MRIreadHeader(fname, MRI_UCHAR); // MRI_CORONAL_SLICE_DIRECTORY) ; } printf(" Read %s\n",fname); fflush(stdout); if (!mri) ErrorExit(ERROR_BADPARM, "%s: could not read reference MRI volume from %s", Progname, fname) ; // save current vertex position into ->cx MRISsaveVertexPositions(mris, CANONICAL_VERTICES) ; // get the vertex position from ->origx, ... // (get the "pial" vertex position) MRISrestoreVertexPositions(mris, ORIGINAL_VERTICES) ; MRIScomputeMetricProperties(mris) ; printf(" Surface area: %2.1f cm^2\n", mris->total_area/100) ; fflush(stdout); average_surface_area += mris->total_area ; // this means that we transform "pial" surface if (xform_name) { if (!strcmp(xform_name,"talairach.xfm")) { printf(" Applying linear transform\n"); fflush(stdout); XFM = DevolveXFMWithSubjectsDir(argv[i], NULL, "talairach.xfm", sdir); if (XFM == NULL) exit(1); MRISmatrixMultiply(mris, XFM); MatrixFree(&XFM); } else if (!strcmp(xform_name,"talairach.m3z")) { printf(" Applying GCA Morph\n"); fflush(stdout); sprintf(fname, "%s/%s/mri/transforms/talairach.m3z", sdir, argv[i]) ; gcam = GCAMreadAndInvert(fname); if (gcam == NULL) exit(1); GCAMmorphSurf(mris, gcam); GCAMfree(&gcam); } else { printf("ERROR: don't know what to do with %s\n",xform_name); exit(1); } } // save transformed position in ->orig // (store "pial" vertices position in orig) MRIScomputeMetricProperties(mris) ; MRISsaveVertexPositions(mris, ORIGINAL_VERTICES) ; // get the vertex position from ->cx // (note that this is not transformed) sphere.reg vertices MRISrestoreVertexPositions(mris, CANONICAL_VERTICES) ; // mris contains sphere.reg in vertex and pial vertices in orig // map to a theta-phi space and accumulate values mrisp = MRIScoordsToParameterization(mris, NULL, SCALE, ORIGINAL_VERTICES) ; MRISPaccumulate(mrisp, mrisp_total, 0) ; MRISPaccumulate(mrisp, mrisp_total, 1) ; MRISPaccumulate(mrisp, mrisp_total, 2) ; MRISPfree(&mrisp) ; MRISfree(&mris) ; MRIfree(&mri) ; //LTAfree(<a) ; fflush(stdout); n++ ; } printf("Finished loading all data\n"); average_surface_area /= (float)n ; printf("Avg surf area = %g cm\n",average_surface_area/100.0); fflush(stdout); // mrisp_total lost info on the modified surface sprintf(ico_fname, "%s/lib/bem/ic%d.tri", mdir, ico_no) ; printf("Reading icosahedron from %s...\n", ico_fname) ; mris_ico = ICOread(ico_fname) ; if (!mris_ico) ErrorExit(ERROR_NOFILE, "%s: could not read icosahedron file %s\n", Progname,ico_fname) ; MRISscaleBrain(mris_ico, mris_ico, DEFAULT_RADIUS/MRISaverageRadius(mris_ico)) ; // save current ico position to ->cx, cy, cz MRISsaveVertexPositions(mris_ico, CANONICAL_VERTICES) ; // using mrisp_total to calculate position into ->origx, origy, origz // (orig is the "pial" vertices) MRIScoordsFromParameterization(mrisp_total, mris_ico, ORIGINAL_VERTICES) ; // copy geometry info memcpy((void *) &mris_ico->vg, (void *) &vg, sizeof (VOL_GEOM)); if (Gdiag_no >= 0 && Gdiag_no < mris_ico->nvertices) { int n ; VERTEX *vn ; v = &mris_ico->vertices[Gdiag_no] ; printf( "v %d: x = (%2.2f, %2.2f, %2.2f)\n", Gdiag_no, v->origx, v->origy, v->origz) ; for (n = 0 ; n < v->vnum ; n++) { vn = &mris_ico->vertices[v->v[n]] ; printf( "v %d: x = (%2.2f, %2.2f, %2.2f)\n", v->v[n], vn->origx, vn->origy, vn->origz) ; } } // write *h.sphere.reg sprintf(fname, "%s/%s/surf/%s.%s", sdirout, out_sname, hemi, canon_surf_name) ; if (Gdiag & DIAG_SHOW) printf("writing average canonical surface to %s\n", fname); MRISwrite(mris_ico, fname) ; // get "pial vertices" from orig MRISrestoreVertexPositions(mris_ico, ORIG_VERTICES); for (vno = 0 ; vno < mris_ico->nvertices ; vno++) { v = &mris_ico->vertices[vno] ; // n = number of subjects v->x /= (float)n ; v->y /= (float)n ; v->z /= (float)n ; } if (normalize_area) { MRIScomputeMetricProperties(mris_ico) ; printf("setting group surface area to be %2.1f cm^2 (scale=%2.2f)\n", average_surface_area/100.0, sqrt(average_surface_area/mris_ico->total_area)) ; #if 0 MRISscaleBrain(mris_ico, mris_ico, sqrt(average_surface_area/mris_ico->total_area)) ; #else mris_ico->group_avg_surface_area = average_surface_area ; #endif MRIScomputeMetricProperties(mris_ico) ; } sprintf(fname, "%s/%s/surf/%s.%s", sdirout,out_sname, hemi, avg_surf_name) ; printf("writing average %s surface to %s\n", avg_surf_name, fname); MRISwrite(mris_ico, fname) ; if (0) { char path[STRLEN] ; LTA *lta ; FileNamePath(fname, path) ; lta = LTAalloc(1, NULL) ; // write to a different location sprintf(fname, "%s/../mri/transforms/%s", path,xform_name) ; LTAwriteEx(lta, fname) ; LTAfree(<a) ; } MRISfree(&mris_ico) ; MRISPfree(&mrisp_total) ; printf("mris_make_average_surface done\n"); exit(0) ; return(0) ; /* for ansi */ }
int main(int argc, char *argv[]) { char **av, *surf_fname, *template_fname, *out_fname, fname[STRLEN],*cp; int ac, nargs,err, msec ; MRI_SURFACE *mris ; MRI_SP *mrisp_template ; char cmdline[CMD_LINE_LEN] ; struct timeb start ; make_cmd_version_string (argc, argv, "$Id: mris_register.c,v 1.59 2011/03/02 00:04:33 nicks Exp $", "$Name: stable5 $", cmdline); /* rkt: check for and handle version tag */ nargs = handle_version_option (argc, argv, "$Id: mris_register.c,v 1.59 2011/03/02 00:04:33 nicks Exp $", "$Name: stable5 $"); if (nargs && argc - nargs == 1) { exit (0); } argc -= nargs; TimerStart(&start) ; Progname = argv[0] ; ErrorInit(NULL, NULL, NULL) ; DiagInit(NULL, NULL, NULL) ; memset(&parms, 0, sizeof(parms)) ; parms.projection = PROJECT_SPHERE ; parms.flags |= IP_USE_CURVATURE ; parms.tol = 0.5 ; // was 1e-0*2.5 parms.min_averages = 0 ; parms.l_area = 0.0 ; parms.l_parea = 0.1f ; // used to be 0.2 parms.l_dist = 5.0 ; // used to be 0.5, and before that 0.1 parms.l_corr = 1.0f ; parms.l_nlarea = 1 ; parms.l_pcorr = 0.0f ; parms.niterations = 25 ; parms.n_averages = 1024 ; // used to be 256 parms.write_iterations = 100 ; parms.dt_increase = 1.01 /* DT_INCREASE */; parms.dt_decrease = 0.99 /* DT_DECREASE*/ ; parms.error_ratio = 1.03 /*ERROR_RATIO */; parms.dt_increase = 1.0 ; parms.dt_decrease = 1.0 ; parms.l_external = 10000 ; /* in case manual label is specified */ parms.error_ratio = 1.1 /*ERROR_RATIO */; parms.integration_type = INTEGRATE_ADAPTIVE ; parms.integration_type = INTEGRATE_MOMENTUM /*INTEGRATE_LINE_MINIMIZE*/ ; parms.integration_type = INTEGRATE_LINE_MINIMIZE ; parms.dt = 0.9 ; parms.momentum = 0.95 ; parms.desired_rms_height = -1.0 ; parms.nbhd_size = -10 ; parms.max_nbrs = 10 ; ac = argc ; av = argv ; for ( ; argc > 1 && ISOPTION(*argv[1]) ; argc--, argv++) { nargs = get_option(argc, argv) ; argc -= nargs ; argv += nargs ; } if (nsigmas > 0) { MRISsetRegistrationSigmas(sigmas, nsigmas) ; } parms.which_norm = which_norm ; if (argc < 4) { usage_exit() ; } printf("%s\n", vcid) ; printf(" %s\n",MRISurfSrcVersion()); fflush(stdout); surf_fname = argv[1] ; template_fname = argv[2] ; out_fname = argv[3] ; if (parms.base_name[0] == 0) { FileNameOnly(out_fname, fname) ; cp = strchr(fname, '.') ; if (cp) { strcpy(parms.base_name, cp+1) ; } else { strcpy(parms.base_name, "sphere") ; } } fprintf(stderr, "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) ; if (parms.var_smoothness) { parms.vsmoothness = (float *)calloc(mris->nvertices, sizeof(float)) ; if (parms.vsmoothness == NULL) { ErrorExit(ERROR_NOMEMORY, "%s: could not allocate vsmoothness array", Progname) ; } parms.dist_error = (float *)calloc(mris->nvertices, sizeof(float)) ; if (parms.dist_error == NULL) { ErrorExit(ERROR_NOMEMORY, "%s: could not allocate dist_error array", Progname) ; } parms.area_error = (float *)calloc(mris->nvertices, sizeof(float)) ; if (parms.area_error == NULL) { ErrorExit(ERROR_NOMEMORY, "%s: could not allocate area_error array", Progname) ; } parms.geometry_error = (float *)calloc(mris->nvertices, sizeof(float)) ; if (parms.geometry_error == NULL) { ErrorExit(ERROR_NOMEMORY, "%s: could not allocate geometry_error array", Progname) ; } } MRISresetNeighborhoodSize(mris, 1) ; if (annot_name) { if (MRISreadAnnotation(mris, annot_name) != NO_ERROR) ErrorExit(ERROR_BADPARM, "%s: could not read annot file %s", Progname, annot_name) ; MRISripMedialWall(mris) ; } MRISsaveVertexPositions(mris, TMP2_VERTICES) ; MRISaddCommandLine(mris, cmdline) ; if (!FZERO(dalpha) || !FZERO(dbeta) || !FZERO(dgamma)) MRISrotate(mris, mris, RADIANS(dalpha), RADIANS(dbeta), RADIANS(dgamma)) ; if (curvature_fname[0]) { fprintf(stderr, "reading source curvature from %s\n",curvature_fname) ; MRISreadCurvatureFile(mris, curvature_fname) ; } if (single_surf) { char fname[STRLEN], *cp, surf_dir[STRLEN], hemi[10] ; MRI_SURFACE *mris_template ; int sno, tnbrs=3 ; FileNamePath(template_fname, surf_dir) ; cp = strrchr(template_fname, '/') ; if (cp == NULL) // no path - start from beginning of file name { cp = template_fname ; } cp = strchr(cp, '.') ; if (cp == NULL) ErrorExit(ERROR_NOFILE, "%s: could no scan hemi from %s", Progname, template_fname) ; strncpy(hemi, cp-2, 2) ; hemi[2] = 0 ; fprintf(stderr, "reading spherical surface %s...\n", template_fname) ; mris_template = MRISread(template_fname) ; if (mris_template == NULL) { ErrorExit(ERROR_NOFILE, "") ; } #if 0 if (reverse_flag) { MRISreverse(mris_template, REVERSE_X, 1) ; } #endif MRISsaveVertexPositions(mris_template, CANONICAL_VERTICES) ; MRIScomputeMetricProperties(mris_template) ; MRISstoreMetricProperties(mris_template) ; if (noverlays > 0) { mrisp_template = MRISPalloc(scale, IMAGES_PER_SURFACE*noverlays); for (sno = 0; sno < noverlays ; sno++) { sprintf(fname, "%s/../label/%s.%s", surf_dir, hemi, overlays[sno]) ; if (MRISreadValues(mris_template, fname) != NO_ERROR) ErrorExit(ERROR_NOFILE, "%s: could not read overlay from %s", Progname, fname) ; MRIScopyValuesToCurvature(mris_template) ; MRISaverageCurvatures(mris_template, navgs) ; MRISnormalizeCurvature(mris_template, which_norm) ; fprintf(stderr, "computing parameterization for overlay %s...\n", fname); MRIStoParameterization(mris_template, mrisp_template, scale, sno*3) ; MRISPsetFrameVal(mrisp_template, sno*3+1, 1.0) ; } } else { mrisp_template = MRISPalloc(scale, PARAM_IMAGES); for (sno = 0; sno < SURFACES ; sno++) { if (curvature_names[sno]) /* read in precomputed curvature file */ { sprintf(fname, "%s/%s.%s", surf_dir, hemi, curvature_names[sno]) ; if (MRISreadCurvatureFile(mris_template, fname) != NO_ERROR) ErrorExit(Gerror, "%s: could not read curvature file '%s'\n", Progname, fname) ; /* the two next lines were not in the original code */ MRISaverageCurvatures(mris_template, navgs) ; MRISnormalizeCurvature(mris_template, which_norm) ; } else /* compute curvature of surface */ { sprintf(fname, "%s/%s.%s", surf_dir, hemi, surface_names[sno]) ; if (MRISreadVertexPositions(mris_template, fname) != NO_ERROR) ErrorExit(ERROR_NOFILE, "%s: could not read surface file %s", Progname, fname) ; if (tnbrs > 1) { MRISresetNeighborhoodSize(mris_template, tnbrs) ; } MRIScomputeMetricProperties(mris_template) ; MRIScomputeSecondFundamentalForm(mris_template) ; MRISuseMeanCurvature(mris_template) ; MRISaverageCurvatures(mris_template, navgs) ; MRISrestoreVertexPositions(mris_template, CANONICAL_VERTICES) ; MRISnormalizeCurvature(mris_template, which_norm) ; } fprintf(stderr, "computing parameterization for surface %s...\n", fname); MRIStoParameterization(mris_template, mrisp_template, scale, sno*3) ; MRISPsetFrameVal(mrisp_template, sno*3+1, 1.0) ; } } } else { fprintf(stderr, "reading template parameterization from %s...\n", template_fname) ; mrisp_template = MRISPread(template_fname) ; if (!mrisp_template) ErrorExit(ERROR_NOFILE, "%s: could not open template file %s", Progname, template_fname) ; if (noverlays > 0) { if (mrisp_template->Ip->num_frame != IMAGES_PER_SURFACE*noverlays) ErrorExit(ERROR_BADPARM, "template frames (%d) doesn't match input (%d x %d) = %d\n", mrisp_template->Ip->num_frame, IMAGES_PER_SURFACE,noverlays, IMAGES_PER_SURFACE*noverlays) ; } } if (use_defaults) { if (*IMAGEFseq_pix(mrisp_template->Ip, 0, 0, 2) <= 1.0) /* 1st time */ { parms.l_dist = 5.0 ; parms.l_corr = 1.0 ; parms.l_parea = 0.2 ; } else /* subsequent alignments */ { parms.l_dist = 5.0 ; parms.l_corr = 1.0 ; parms.l_parea = 0.2 ; } } if (nbrs > 1) { MRISresetNeighborhoodSize(mris, nbrs) ; } MRISprojectOntoSphere(mris, mris, DEFAULT_RADIUS) ; mris->status = MRIS_PARAMETERIZED_SPHERE ; MRIScomputeMetricProperties(mris) ; if (!FZERO(parms.l_dist)) { MRISscaleDistances(mris, scale) ; } #if 0 MRISsaveVertexPositions(mris, ORIGINAL_VERTICES) ; MRISzeroNegativeAreas(mris) ; MRISstoreMetricProperties(mris) ; #endif MRISstoreMeanCurvature(mris) ; /* use curvature from file */ MRISsetOriginalFileName(orig_name) ; if (inflated_name) { MRISsetInflatedFileName(inflated_name) ; } err = MRISreadOriginalProperties(mris, orig_name) ; if (err != 0) { printf("ERROR %d from MRISreadOriginalProperties().\n",err); exit(1); } if (MRISreadCanonicalCoordinates(mris, canon_name) != NO_ERROR) ErrorExit(ERROR_BADFILE, "%s: could not read canon surface %s", Progname, canon_name) ; if (reverse_flag) { MRISreverse(mris, REVERSE_X, 1) ; MRISsaveVertexPositions(mris, TMP_VERTICES) ; MRISrestoreVertexPositions(mris, CANONICAL_VERTICES) ; MRISreverse(mris, REVERSE_X, 0) ; MRISsaveVertexPositions(mris, CANONICAL_VERTICES) ; MRISrestoreVertexPositions(mris, TMP_VERTICES) ; MRIScomputeMetricProperties(mris) ; } #if 0 MRISsaveVertexPositions (mris, CANONICAL_VERTICES) ; // uniform spherical positions #endif if (starting_reg_fname) if (MRISreadVertexPositions(mris, starting_reg_fname) != NO_ERROR) { exit(Gerror) ; } if (multiframes) { if (use_initial_registration) MRISvectorRegister(mris, mrisp_template, &parms, max_passes, min_degrees, max_degrees, nangles) ; parms.l_corr=parms.l_pcorr=0.0f; #if 0 parms.l_dist = 0.0 ; parms.l_corr = 0.0 ; parms.l_parea = 0.0 ; parms.l_area = 0.0 ; parms.l_parea = 0.0f ; parms.l_dist = 0.0 ; parms.l_corr = 0.0f ; parms.l_nlarea = 0.0f ; parms.l_pcorr = 0.0f ; #endif MRISvectorRegister(mris, mrisp_template, &parms, max_passes, min_degrees, max_degrees, nangles) ; } else { double l_dist = parms.l_dist ; if (multi_scale > 0) { int i ; parms.l_dist = l_dist * pow(5.0, (multi_scale-1.0)) ; parms.flags |= IPFLAG_NOSCALE_TOL ; parms.flags &= ~IP_USE_CURVATURE ; for (i = 0 ; i < multi_scale ; i++) { printf("*************** round %d, l_dist = %2.3f **************\n", i, parms.l_dist) ; MRISregister(mris, mrisp_template, &parms, max_passes, min_degrees, max_degrees, nangles) ; parms.flags |= IP_NO_RIGID_ALIGN ; parms.flags &= ~IP_USE_INFLATED ; parms.l_dist /= 5 ; } if (parms.nbhd_size < 0) { parms.nbhd_size *= -1 ; printf("**** starting 2nd epoch, with long-range distances *****\n"); parms.l_dist = l_dist * pow(5.0, (multi_scale-2.0)) ; for (i = 1 ; i < multi_scale ; i++) { printf("*********** round %d, l_dist = %2.3f *************\n", i, parms.l_dist) ; MRISregister(mris, mrisp_template, &parms, max_passes, min_degrees, max_degrees, nangles) ; parms.l_dist /= 5 ; } } printf("****** final curvature registration ***************\n") ; if (parms.nbhd_size > 0) { parms.nbhd_size *= -1 ; // disable long-range stuff } parms.l_dist *= 5 ; parms.flags |= (IP_USE_CURVATURE | IP_NO_SULC); MRISregister(mris, mrisp_template, &parms, max_passes, min_degrees, max_degrees, nangles) ; } else MRISregister(mris, mrisp_template, &parms, max_passes, min_degrees, max_degrees, nangles) ; } if (remove_negative) { parms.niterations = 1000 ; MRISremoveOverlapWithSmoothing(mris,&parms) ; } fprintf(stderr, "writing registered surface to %s...\n", out_fname) ; MRISwrite(mris, out_fname) ; if (jacobian_fname) { MRIScomputeMetricProperties(mris) ; compute_area_ratios(mris) ; /* will put results in v->curv */ #if 0 MRISwriteArea(mris, jacobian_fname) ; #else MRISwriteCurvature(mris, jacobian_fname) ; #endif } msec = TimerStop(&start) ; if (Gdiag & DIAG_SHOW) printf("registration took %2.2f hours\n", (float)msec/(1000.0f*60.0f*60.0f)); MRISPfree(&mrisp_template) ; MRISfree(&mris) ; exit(0) ; return(0) ; /* for ansi */ }
int main(int argc, char *argv[]) { char **av, *source_fname, *target_fname, *out_fname, fname[STRLEN] ; int ac, nargs, new_transform = 0, pad ; MRI *mri_target, *mri_source, *mri_orig_source ; MRI_REGION box ; struct timeb start ; int msec, minutes, seconds ; GCA_MORPH *gcam ; MATRIX *m_L/*, *m_I*/ ; LTA *lta ; /* initialize the morph params */ memset(&mp, 0, sizeof(GCA_MORPH_PARMS)); /* for nonlinear morph */ mp.l_jacobian = 1 ; mp.min_sigma = 0.4 ; mp.l_distance = 0 ; mp.l_log_likelihood = .025 ; mp.dt = 0.005 ; mp.noneg = True ; mp.exp_k = 20 ; mp.diag_write_snapshots = 1 ; mp.momentum = 0.9 ; if (FZERO(mp.l_smoothness)) mp.l_smoothness = 2 ; mp.sigma = 8 ; mp.relabel_avgs = -1 ; mp.navgs = 256 ; mp.levels = 6 ; mp.integration_type = GCAM_INTEGRATE_BOTH ; mp.nsmall = 1 ; mp.reset_avgs = -1 ; mp.npasses = 3 ; mp.regrid = regrid? True : False ; mp.tol = 0.1 ; mp.niterations = 1000 ; TimerStart(&start) ; setRandomSeed(-1L) ; DiagInit(NULL, NULL, NULL) ; ErrorInit(NULL, NULL, NULL) ; Progname = argv[0] ; 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) ; source_fname = argv[1] ; target_fname = argv[2] ; out_fname = argv[3] ; FileNameOnly(out_fname, fname) ; FileNameRemoveExtension(fname, fname) ; strcpy(mp.base_name, fname) ; mri_source = MRIread(source_fname) ; if (!mri_source) ErrorExit(ERROR_NOFILE, "%s: could not read source label volume %s", Progname, source_fname) ; if (mri_source->type == MRI_INT) { MRI *mri_tmp = MRIchangeType(mri_source, MRI_FLOAT, 0, 1, 1) ; MRIfree(&mri_source); mri_source = mri_tmp ; } mri_target = MRIread(target_fname) ; if (!mri_target) ErrorExit(ERROR_NOFILE, "%s: could not read target label volume %s", Progname, target_fname) ; if (mri_target->type == MRI_INT) { MRI *mri_tmp = MRIchangeType(mri_target, MRI_FLOAT, 0, 1, 1) ; MRIfree(&mri_target); mri_target = mri_tmp ; } if (erosions > 0) { int n ; for (n = 0 ; n < erosions ; n++) { MRIerodeZero(mri_target, mri_target) ; MRIerodeZero(mri_source, mri_source) ; } } if (scale_values > 0) { MRIscalarMul(mri_source, mri_source, scale_values) ; MRIscalarMul(mri_target, mri_target, scale_values) ; } if (transform && transform->type == MORPH_3D_TYPE) TransformRas2Vox(transform, mri_source,NULL) ; if (use_aseg == 0) { if (match_peak_intensity_ratio) MRImatchIntensityRatio(mri_source, mri_target, mri_source, .8, 1.2, 100, 125) ; else if (match_mean_intensity) MRImatchMeanIntensity(mri_source, mri_target, mri_source) ; MRIboundingBox(mri_source, 0, &box) ; pad = (int)ceil(PADVOX * MAX(mri_target->xsize,MAX(mri_target->ysize,mri_target->zsize)) / MIN(mri_source->xsize,MIN(mri_source->ysize,mri_source->zsize))); #if 0 { MRI *mri_tmp ; if (pad < 1) pad = 1 ; printf("padding source with %d voxels...\n", pad) ; mri_tmp = MRIextractRegionAndPad(mri_source, NULL, &box, pad) ; if ((Gdiag & DIAG_WRITE) && DIAG_VERBOSE_ON) MRIwrite(mri_tmp, "t.mgz") ; MRIfree(&mri_source) ; mri_source = mri_tmp ; } #endif } mri_orig_source = MRIcopy(mri_source, NULL) ; mp.max_grad = 0.3*mri_source->xsize ; if (transform == NULL) transform = TransformAlloc(LINEAR_VOXEL_TO_VOXEL, NULL) ; if (transform->type != MORPH_3D_TYPE) // initializing m3d from a linear transform { new_transform = 1 ; lta = ((LTA *)(transform->xform)) ; if (lta->type != LINEAR_VOX_TO_VOX) { printf("converting ras xform to voxel xform\n") ; m_L = MRIrasXformToVoxelXform(mri_source, mri_target, lta->xforms[0].m_L, NULL) ; MatrixFree(<a->xforms[0].m_L) ; lta->type = LINEAR_VOX_TO_VOX ; } else { printf("using voxel xform\n") ; m_L = lta->xforms[0].m_L ; } #if 0 if (Gsx >= 0) // update debugging coords { VECTOR *v1, *v2 ; v1 = VectorAlloc(4, MATRIX_REAL) ; Gsx -= (box.x-pad) ; Gsy -= (box.y-pad) ; Gsz -= (box.z-pad) ; V3_X(v1) = Gsx ; V3_Y(v1) = Gsy ; V3_Z(v1) = Gsz ; VECTOR_ELT(v1,4) = 1.0 ; v2 = MatrixMultiply(m_L, v1, NULL) ; Gsx = nint(V3_X(v2)) ; Gsy = nint(V3_Y(v2)) ; Gsz = nint(V3_Z(v2)) ; MatrixFree(&v2) ; MatrixFree(&v1) ; printf("mapping by transform (%d, %d, %d) --> (%d, %d, %d) for rgb writing\n", Gx, Gy, Gz, Gsx, Gsy, Gsz) ; } #endif if (Gdiag & DIAG_WRITE && DIAG_VERBOSE_ON) write_snapshot(mri_target, mri_source, m_L, &mp, 0, 1, "linear_init"); lta->xforms[0].m_L = m_L ; printf("initializing GCAM with vox->vox matrix:\n") ; MatrixPrint(stdout, m_L) ; gcam = GCAMcreateFromIntensityImage(mri_source, mri_target, transform) ; #if 0 gcam->gca = gcaAllocMax(1, 1, 1, mri_target->width, mri_target->height, mri_target->depth, 0, 0) ; #endif GCAMinitVolGeom(gcam, mri_source, mri_target) ; if (use_aseg) { if (ribbon_name) { char fname[STRLEN], path[STRLEN], *str, *hemi ; int h, s, label ; MRI_SURFACE *mris_white, *mris_pial ; MRI *mri ; for (s = 0 ; s <= 1 ; s++) // source and target { if (s == 0) { str = source_surf ; mri = mri_source ; FileNamePath(mri->fname, path) ; strcat(path, "/../surf") ; } else { mri = mri_target ; FileNamePath(mri->fname, path) ; strcat(path, "/../elastic") ; str = target_surf ; } // sorry - these values come from FreeSurferColorLUT.txt MRIreplaceValueRange(mri, mri, 1000, 1034, Left_Cerebral_Cortex) ; MRIreplaceValueRange(mri, mri, 1100, 1180, Left_Cerebral_Cortex) ; MRIreplaceValueRange(mri, mri, 2000, 2034, Right_Cerebral_Cortex) ; MRIreplaceValueRange(mri, mri, 2100, 2180, Right_Cerebral_Cortex) ; for (h = LEFT_HEMISPHERE ; h <= RIGHT_HEMISPHERE ; h++) { if (h == LEFT_HEMISPHERE) { hemi = "lh" ; label = Left_Cerebral_Cortex ; } else { label = Right_Cerebral_Cortex ; hemi = "rh" ; } sprintf(fname, "%s/%s%s.white", path, hemi, str) ; mris_white = MRISread(fname) ; if (mris_white == NULL) ErrorExit(ERROR_NOFILE, "%s: could not read surface %s", Progname, fname) ; MRISsaveVertexPositions(mris_white, WHITE_VERTICES) ; sprintf(fname, "%s/%s%s.pial", path, hemi, str) ; mris_pial = MRISread(fname) ; if (mris_pial == NULL) ErrorExit(ERROR_NOFILE, "%s: could not read surface %s", Progname, fname) ; MRISsaveVertexPositions(mris_pial, PIAL_VERTICES) ; if (Gdiag & DIAG_WRITE && DIAG_VERBOSE_ON) { sprintf(fname, "sb.mgz") ; MRIwrite(mri_source, fname) ; sprintf(fname, "tb.mgz") ; MRIwrite(mri_target, fname) ; } insert_ribbon_into_aseg(mri, mri, mris_white, mris_pial, h) ; if (Gdiag & DIAG_WRITE && DIAG_VERBOSE_ON) { sprintf(fname, "sa.mgz") ; MRIwrite(mri_source, fname) ; sprintf(fname, "ta.mgz") ; MRIwrite(mri_target, fname) ; } MRISfree(&mris_white) ; MRISfree(&mris_pial) ; } } if (Gdiag & DIAG_WRITE && DIAG_VERBOSE_ON) { sprintf(fname, "s.mgz") ; MRIwrite(mri_source, fname) ; sprintf(fname, "t.mgz") ; MRIwrite(mri_target, fname) ; } } GCAMinitLabels(gcam, mri_target) ; GCAMsetVariances(gcam, 1.0) ; mp.mri_dist_map = create_distance_transforms(mri_source, mri_target, NULL, 40.0, gcam) ; } } else /* use a previously create morph and integrate it some more */ { printf("using previously create gcam...\n") ; gcam = (GCA_MORPH *)(transform->xform) ; GCAMrasToVox(gcam, mri_source) ; if (use_aseg) { GCAMinitLabels(gcam, mri_target) ; GCAMsetVariances(gcam, 1.0) ; mp.mri_dist_map = create_distance_transforms(mri_source, mri_target, NULL, 40.0, gcam) ; } else GCAMaddIntensitiesFromImage(gcam, mri_target) ; } if (gcam->width != mri_source->width || gcam->height != mri_source->height || gcam->depth != mri_source->depth) ErrorExit(ERROR_BADPARM, "%s: warning gcam (%d, %d, %d), doesn't match source vol (%d, %d, %d)", Progname, gcam->width, gcam->height, gcam->depth, mri_source->width, mri_source->height, mri_source->depth) ; mp.mri_diag = mri_source ; mp.diag_morph_from_atlas = 0 ; mp.diag_write_snapshots = 1 ; mp.diag_sample_type = use_aseg ? SAMPLE_NEAREST : SAMPLE_TRILINEAR ; mp.diag_volume = use_aseg ? GCAM_LABEL : GCAM_MEANS ; if (renormalize) GCAMnormalizeIntensities(gcam, mri_target) ; if (mp.write_iterations != 0) { char fname[STRLEN] ; MRI *mri_gca ; if (getenv("DONT_COMPRESS")) sprintf(fname, "%s_target.mgh", mp.base_name) ; else sprintf(fname, "%s_target.mgz", mp.base_name) ; if (mp.diag_morph_from_atlas == 0) { printf("writing target volume to %s...\n", fname) ; MRIwrite(mri_target, fname) ; sprintf(fname, "%s_target", mp.base_name) ; MRIwriteImageViews(mri_target, fname, IMAGE_SIZE) ; } else { if (use_aseg) mri_gca = GCAMwriteMRI(gcam, NULL, GCAM_LABEL) ; else { mri_gca = MRIclone(mri_source, NULL) ; GCAMbuildMostLikelyVolume(gcam, mri_gca) ; } printf("writing target volume to %s...\n", fname) ; MRIwrite(mri_gca, fname) ; sprintf(fname, "%s_target", mp.base_name) ; MRIwriteImageViews(mri_gca, fname, IMAGE_SIZE) ; MRIfree(&mri_gca) ; } } if (nozero) { printf("disabling zero nodes\n") ; GCAMignoreZero(gcam, mri_target) ; } mp.mri = mri_target ; if (mp.regrid == True && new_transform == 0) GCAMregrid(gcam, mri_target, PAD, &mp, &mri_source) ; mp.write_fname = out_fname ; GCAMregister(gcam, mri_source, &mp) ; // atlas is target, morph target into register with it if (apply_transform) { MRI *mri_aligned ; char fname[STRLEN] ; FileNameRemoveExtension(out_fname, fname) ; strcat(fname, ".mgz") ; mri_aligned = GCAMmorphToAtlas(mp.mri, gcam, NULL, -1, mp.diag_sample_type) ; printf("writing transformed output volume to %s...\n", fname) ; MRIwrite(mri_aligned, fname) ; MRIfree(&mri_aligned) ; } printf("writing warp vector field to %s\n", out_fname) ; GCAMvoxToRas(gcam) ; GCAMwrite(gcam, out_fname) ; GCAMrasToVox(gcam, mri_source) ; msec = TimerStop(&start) ; seconds = nint((float)msec/1000.0f) ; minutes = seconds / 60 ; seconds = seconds % 60 ; printf("registration took %d minutes and %d seconds.\n", minutes, seconds) ; exit(0) ; return(0) ; }
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[]) { char *inner_mris_fname_lh,*outer_mris_fname_lh, *inner_mris_fname_rh,*outer_mris_fname_rh, *input_mri_pref,*output_mri_pref,*mask_mri_pref; MRI *mri,*mri_src,*mri_mask; MRI_SURFACE *inner_mris_lh,*outer_mris_lh,*inner_mris_rh,*outer_mris_rh; int nargs; /* rkt: check for and handle version tag */ nargs = handle_version_option (argc, argv, "$Id: mri_partial_ribbon.c,v 1.11 2011/03/02 00:04:23 nicks Exp $", "$Name: $"); if (nargs && argc - nargs == 1) exit (0); argc -= nargs; /* Set command-line parameters */ if (argc < 7) { usage(); exit(-1); } Progname=argv[0]; inner_mris_fname_lh=argv[1]; // lh.white outer_mris_fname_lh=argv[2]; // lh.pial inner_mris_fname_rh=argv[3]; // rh.white outer_mris_fname_rh=argv[4]; // rh.pial input_mri_pref=argv[5]; // volume output_mri_pref=argv[6]; // output if (argc==8) mask_mri_pref=argv[7]; // cma mask else mask_mri_pref=NULL; /* Read surface information from left inner surface file */ printf("Reading left inner surface file %s.\n",inner_mris_fname_lh); inner_mris_lh=MRISread(inner_mris_fname_lh); if (!inner_mris_lh) { fprintf(stderr,"Could not read surface file %s.\n",inner_mris_fname_lh); exit(1); } /* Read surface information from left outer surface file */ printf("Reading left outer surface file %s.\n",outer_mris_fname_lh); outer_mris_lh=MRISread(outer_mris_fname_lh); if (!outer_mris_lh) { fprintf(stderr,"Could not read surface file %s.\n",outer_mris_fname_lh); exit(1); } /* Read surface information from right inner surface file */ printf("Reading right inner surface file %s.\n",inner_mris_fname_rh); inner_mris_rh=MRISread(inner_mris_fname_rh); if (!inner_mris_rh) { fprintf(stderr,"Could not read surface file %s.\n",inner_mris_fname_rh); exit(1); } /* Read surface information from right outer surface file */ printf("Reading right outer surface file %s.\n",outer_mris_fname_rh); outer_mris_rh=MRISread(outer_mris_fname_rh); if (!outer_mris_rh) { fprintf(stderr,"Could not read surface file %s.\n",outer_mris_fname_rh); exit(1); } /* Read example volume from file */ printf("Reading MRI volume directory %s.\n",input_mri_pref); mri_src=MRIread(input_mri_pref); if (!mri_src) { fprintf(stderr,"Could not read MRI volume directory %s.\n",input_mri_pref); exit(1); } /* Read example volume from file */ if (argc==8) { printf("Reading MRI volume directory %s.\n",mask_mri_pref); mri_mask=MRIread(mask_mri_pref); if (!mri_mask) { fprintf(stderr,"Could not read MRI volume directory %s.\n", mask_mri_pref); exit(1); } } else mri_mask=NULL; /* Extract ribbon */ printf("Extracting ribbon.\n"); mri=MRISpartialribbon(inner_mris_lh, outer_mris_lh, inner_mris_rh, outer_mris_rh, mri_src, NULL, mri_mask); /* Save MRI volume to directory */ printf("Writing volume file %s.\n",output_mri_pref); MRIwrite(mri,output_mri_pref); MRIfree(&mri); MRIfree(&mri_src); if (mri_mask) MRIfree(&mri_mask); MRISfree(&inner_mris_lh); MRISfree(&outer_mris_lh); MRISfree(&inner_mris_rh); MRISfree(&outer_mris_rh); return 0; }
/*-------------------------------------------------------------------------*/ static int connect_path(char* fname, char* ofname, char *subject, char *hemi) { int err; int num_paths; PATH **paths = NULL, *newpath; int *vtxnolist,*final_path, path_length, k, vtxno; char tmpstr[2000]; MRIS *mris; /* Read the paths file. */ err = PathReadMany (fname, &num_paths, &paths); if (ERROR_NONE != err) { ErrorReturn (ERROR_BADFILE, (ERROR_BADFILE, "Couldn't read %s", fname)); } /* Warn if we have more than one path. */ if (num_paths != 1) { printf ("WARNING: Found multiple paths in paths file. \n" "Maybe you didn't mean to use the connect option?\n" "Will only convert first path\n\n"); } sprintf(tmpstr,"%s/%s/surf/%s.orig",getenv("SUBJECTS_DIR"),subject,hemi); printf("Reading %s\n",tmpstr); mris = MRISread(tmpstr); if(mris == NULL) exit(1); final_path = (int*) calloc(mris->nvertices,sizeof(int)); vtxnolist = (int*) calloc(paths[0]->n_points,sizeof(int)); for(k=0; k < paths[0]->n_points; k++) vtxnolist[k] = paths[0]->points[k].vno; MRISfindPath(vtxnolist, paths[0]->n_points, mris->nvertices, final_path, &path_length, mris ); newpath = PathAlloc(path_length,""); newpath->n_points = path_length; newpath->points = (PATH_POINT *) calloc(path_length,sizeof(PATH_POINT)); for(k=0; k < path_length; k++){ vtxno = final_path[k]; newpath->points[k].vno = vtxno; newpath->points[k].x = mris->vertices[vtxno].x; newpath->points[k].y = mris->vertices[vtxno].y; newpath->points[k].z = mris->vertices[vtxno].z; } /* Write the path file. */ err = PathWriteMany (ofname, 1, &newpath); if (0 != err) { ErrorReturn (ERROR_BADFILE, (ERROR_BADFILE, "Couldn't write to %s", ofname)); } PathFree(&paths[0]); free (paths); PathFree(&newpath); MRISfree(&mris); free(final_path); free(vtxnolist); return(ERROR_NONE); }