int MRIScomputeNeighbors(MRI_SURFACE *mris, float max_mm) { int vno, n, vlist[MAX_NBHD_SIZE], nbrs, done, found, m, nbhd, first =1 ; VERTEX *v, *vn, *vn2 ; float dist, dx, dy, dz ; MRISresetNeighborhoodSize(mris, -1) ; /* back to max */ for (vno = 0 ; vno < mris->nvertices ; vno++) { v = &mris->vertices[vno] ; if (v->ripflag) { continue ; } if (vno == Gdiag_no) { DiagBreak() ; } for (n = 0 ; n < v->vtotal ; n++) { mris->vertices[v->v[n]].marked = 1 ; vlist[n] = v->v[n] ; } nbhd = v->nsize+1 ; nbrs = v->vtotal ; do { found = 0 ; for (n = 0 ; n < nbrs ; n++) { vn = &mris->vertices[vlist[n]] ; for (m = 0 ; m < vn->vnum ; m++) { vn2 = &mris->vertices[vn->v[m]] ; if (vn2->marked) // already in the nbhd list { continue ; } dx = vn2->cx - v->cx ; dy = vn2->cy - v->cy ; dz = vn2->cz - v->cz ; dist = sqrt(dx*dx + dy*dy + dz*dz) ; if (dist < max_mm) { vlist[nbrs] = vn->v[m] ; nbrs++ ; found++ ; vn2->marked = 1 ; if (nbrs >= MAX_NBHD_SIZE) { if (first) { printf("max nbrs %d exceeded at vertex %d\n", nbrs, vno) ; } first = 0 ; break ; } } } } done = ((found == 0) || (nbrs >= MAX_NBHD_SIZE)) ; } while (!done) ; free(v->v) ; v->v = (int *)calloc(nbrs, sizeof(int)) ; if (v->v == NULL) ErrorExit(ERROR_NOMEMORY, "%s: vno %d could not allocate %d vertex array", Progname, vno, nbrs) ; memmove(v->v, vlist, sizeof(vlist[0])*nbrs) ; v->vtotal = nbrs ; for (n = 0 ; n < nbrs ; n++) { mris->vertices[vlist[n]].marked = 0 ; } } return(NO_ERROR) ; }
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, *in_surf_fname, *out_fname, fname[STRLEN], *cp ; int ac, nargs, msec, err ; MRI_SURFACE *mris ; struct timeb then ; float max_dim ; char cmdline[CMD_LINE_LEN] ; make_cmd_version_string (argc, argv, "$Id: mris_sphere.c,v 1.57 2011/03/02 00:04:34 nicks Exp $", "$Name: stable5 $", cmdline); /* rkt: check for and handle version tag */ nargs = handle_version_option (argc, argv, "$Id: mris_sphere.c,v 1.57 2011/03/02 00:04:34 nicks Exp $", "$Name: stable5 $"); if (nargs && argc - nargs == 1) { exit (0); } argc -= nargs; #ifdef FS_CUDA /* print GPU device info */ MRISCdeviceInfo(); #endif // FS_CUDA TimerStart(&then) ; Progname = argv[0] ; ErrorInit(NULL, NULL, NULL) ; DiagInit(NULL, NULL, NULL) ; memset(&parms, 0, sizeof(parms)) ; parms.dt = .05 ; parms.projection = PROJECT_ELLIPSOID ; parms.tol = .5 /*1e-1*/ ; parms.n_averages = 1024 ; parms.min_averages = 0 ; parms.l_angle = 0.0 /* L_ANGLE */ ; parms.l_area = 0.0 /* L_AREA */ ; parms.l_neg = 0.0 ; parms.l_dist = 1.0 ; parms.l_spring = 0.0 ; parms.l_area = 1.0 ; parms.l_boundary = 0.0 ; parms.l_curv = 0.0 ; parms.niterations = 25 ; parms.write_iterations = 1000 ; parms.a = parms.b = parms.c = 0.0f ; /* ellipsoid parameters */ parms.dt_increase = 1.01 /* DT_INCREASE */; parms.dt_decrease = 0.99 /* 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.Hdesired = 0.0 ; /* a flat surface */ parms.nbhd_size = 7 ; parms.max_nbrs = 8 ; ac = argc ; av = argv ; for ( ; argc > 1 && ISOPTION(*argv[1]) ; argc--, argv++) { nargs = get_option(argc, argv) ; argc -= nargs ; argv += nargs ; } parms.scale = scale ; if (argc != 3) // catches args beyond the expected two { usage_exit() ; } parms.base_dt = base_dt_scale * parms.dt ; in_surf_fname = argv[1] ; out_fname = argv[2] ; printf("%s\n",vcid); printf(" %s\n",MRISurfSrcVersion()); fflush(stdout); 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") ; } } mris = MRISread(in_surf_fname) ; if (!mris) ErrorExit(ERROR_NOFILE, "%s: could not read surface file %s", Progname, in_surf_fname) ; MRISaddCommandLine(mris, cmdline) ; fprintf(stderr, "reading original vertex positions...\n") ; if (!FZERO(disturb)) { mrisDisturbVertices(mris, disturb) ; } if (quick == 0) { // don't need original properties unless preserving metric err = MRISreadOriginalProperties(mris, orig_name) ; if(err) { exit(1); } } if (smooth_avgs > 0) { MRISsaveVertexPositions(mris, TMP_VERTICES) ; MRISrestoreVertexPositions(mris, ORIGINAL_VERTICES) ; MRISaverageVertexPositions(mris, smooth_avgs) ; MRISsaveVertexPositions(mris, ORIGINAL_VERTICES) ; MRISrestoreVertexPositions(mris, TMP_VERTICES) ; } if (!FZERO(ralpha) || !FZERO(rbeta) || !FZERO(rgamma)) { MRISrotate(mris,mris,RADIANS(ralpha),RADIANS(rbeta),RADIANS(rgamma)) ; // if (Gdiag & DIAG_WRITE && DIAG_VERBOSE_ON) MRISwrite(mris, "rot") ; } fprintf(stderr, "unfolding cortex into spherical form...\n"); if (talairach) { MRIStalairachTransform(mris, mris) ; MRISwrite(mris, "tal") ; } if (xform_fname) { LTA *lta ; MRI *mri ; TRANSFORM transform ; lta = LTAread(xform_fname) ; if (lta == NULL) { ErrorExit(ERROR_NOFILE, "%s: could not load %s", xform_fname) ; } mri = MRIread(vol_fname) ; if (mri == NULL) { ErrorExit(ERROR_NOFILE, "%s: could not load %s", vol_fname) ; } transform.type = lta->type ; transform.xform = (void *)lta ; MRIStransform(mris, mri, &transform, mri) ; MRIfree(&mri) ; LTAfree(<a) ; MRISwrite(mris, "xfm") ; } #if 0 max_dim = MAX(abs(mris->xlo), abs(mris->xhi)) ; max_dim = MAX(abs(max_dim), abs(mris->ylo)) ; max_dim = MAX(abs(max_dim), abs(mris->yhi)) ; max_dim = MAX(abs(max_dim), abs(mris->zlo)) ; max_dim = MAX(abs(max_dim), abs(mris->zhi)) ; #else max_dim = MAX(abs(mris->xhi-mris->xlo), abs(mris->yhi-mris->ylo)) ; max_dim = MAX(max_dim,abs(mris->zhi-mris->zlo)) ; #endif if (max_dim > .75*DEFAULT_RADIUS) { float ratio = .75*DEFAULT_RADIUS / (max_dim) ; printf("scaling brain by %2.3f...\n", ratio) ; MRISscaleBrain(mris, mris, ratio) ; } if (target_radius < 0) { target_radius = sqrt(mris->total_area / (4*M_PI)) ; printf("setting target radius to be %2.3f to match surface areas\n", target_radius) ; } // MRISsampleAtEachDistance(mris, parms.nbhd_size, parms.max_nbrs) ; if (!load && inflate) { INTEGRATION_PARMS inflation_parms ; MRIScenter(mris, mris) ; memset(&inflation_parms, 0, sizeof(INTEGRATION_PARMS)) ; strcpy(inflation_parms.base_name, parms.base_name) ; inflation_parms.write_iterations = parms.write_iterations ; inflation_parms.niterations = inflate_iterations ; inflation_parms.l_spring_norm = l_spring_norm ; inflation_parms.l_spring = inflate_spring ; inflation_parms.l_nlarea = inflate_nlarea ; inflation_parms.l_area = inflate_area ; inflation_parms.n_averages = inflate_avgs ; inflation_parms.l_expand = l_expand ; inflation_parms.l_tspring = inflate_tspring ; inflation_parms.l_sphere = l_sphere ; inflation_parms.l_convex = l_convex ; #define SCALE_UP 2 inflation_parms.a = SCALE_UP*DEFAULT_RADIUS ; inflation_parms.tol = inflate_tol ; inflation_parms.integration_type = INTEGRATE_MOMENTUM ; inflation_parms.momentum = 0.9 ; inflation_parms.dt = inflate_dt ; /* store the inflated positions in the v->c? field so that they can be used in the repulsive term. */ /* inflation_parms.l_repulse_ratio = .1 ;*/ MRISsaveVertexPositions(mris, CANONICAL_VERTICES) ; if (l_expand > 0) { MRISexpandSurface(mris, target_radius/2, &inflation_parms, 0, 1) ; l_expand = parms.l_expand = 0 ; } MRIScenter(mris, mris) ; mris->x0 = mris->xctr ; mris->y0 = mris->yctr ; mris->z0 = mris->zctr ; MRISinflateToSphere(mris, &inflation_parms) ; if (inflation_parms.l_expand > 0) { inflation_parms.l_expand = 0 ; inflation_parms.niterations += (inflate_iterations*.1) ; MRISinflateToSphere(mris, &inflation_parms) ; } MRISscaleBrain(mris, mris, target_radius/(DEFAULT_RADIUS*SCALE_UP)) ; parms.start_t = inflation_parms.start_t ; MRISresetNeighborhoodSize(mris, nbrs) ; } if (Gdiag & DIAG_WRITE && DIAG_VERBOSE_ON) { MRISwrite(mris, "before") ; } MRISprojectOntoSphere(mris, mris, target_radius) ; if (Gdiag & DIAG_WRITE && DIAG_VERBOSE_ON) { MRISwrite(mris, "after") ; } fprintf(stderr,"surface projected - minimizing metric distortion...\n"); MRISsetNeighborhoodSize(mris, nbrs) ; if (quick) { if (!load) { #if 0 parms.n_averages = 32 ; parms.tol = .1 ; parms.l_parea = parms.l_dist = 0.0 ; parms.l_nlarea = 1 ; #endif MRISprintTessellationStats(mris, stderr) ; MRISquickSphere(mris, &parms, max_passes) ; } } else { MRISunfold(mris, &parms, max_passes) ; } if (remove_negative) { parms.niterations = 1000 ; MRISremoveOverlapWithSmoothing(mris,&parms) ; } if (!load) { fprintf(stderr, "writing spherical brain to %s\n", out_fname) ; MRISwrite(mris, out_fname) ; } msec = TimerStop(&then) ; fprintf(stderr, "spherical transformation took %2.2f hours\n", (float)msec/(1000.0f*60.0f*60.0f)); 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 */ }