int
main(int argc, char *argv[])
{
char **av, *in_fname,fname[STRLEN],hemi[10], path[STRLEN],
name[STRLEN],*cp ;
int ac, nargs, nhandles ;
MRI_SURFACE *mris ;
double ici, fi, var ;
/* rkt: check for and handle version tag */
nargs = handle_version_option
(argc, argv,
"$Id: mris_curvature.c,v 1.31 2011/03/02 00:04:30 nicks Exp $",
"$Name: stable5 $");
if (nargs && argc - nargs == 1)
{
exit (0);
}
argc -= nargs;
Progname = argv[0] ;
ErrorInit(NULL, NULL, NULL) ;
DiagInit(NULL, NULL, NULL) ;
ac = argc ;
av = argv ;
for ( ; argc > 1 && ISOPTION(*argv[1]) ; argc--, argv++)
{
nargs = get_option(argc, argv) ;
argc -= nargs ;
argv += nargs ;
}
if (argc < 2)
{
usage_exit() ;
}
in_fname = argv[1] ;
FileNamePath(in_fname, path) ;
FileNameOnly(in_fname, name) ;
cp = strchr(name, '.') ;
if (!cp)
ErrorExit(ERROR_BADPARM, "%s: could not scan hemisphere from '%s'",
Progname, fname) ;
strncpy(hemi, cp-2, 2) ;
hemi[2] = 0 ;
if (patch_flag) /* read the orig surface, then the patch file */
{
sprintf(fname, "%s/%s.orig", path, hemi) ;
mris = MRISfastRead(fname) ;
if (!mris)
ErrorExit(ERROR_NOFILE, "%s: could not read surface file %s",
Progname, in_fname) ;
if (Gdiag & DIAG_SHOW)
{
fprintf(stderr, "reading patch file %s...\n", in_fname) ;
}
if (MRISreadPatch(mris, in_fname) != NO_ERROR)
ErrorExit(ERROR_NOFILE, "%s: could not read patch file %s",
Progname, in_fname) ;
}
else /* just read the surface normally */
{
mris = MRISread(in_fname) ;
if (!mris)
ErrorExit(ERROR_NOFILE, "%s: could not read surface file %s",
Progname, in_fname) ;
}
MRISsetNeighborhoodSize(mris, nbrs) ;
if (nbhd_size > 0)
{
MRISsampleAtEachDistance(mris, nbhd_size, nbrs_per_distance) ;
}
if (max_mm > 0)
{
float ratio ;
MRISstoreMetricProperties(mris) ;
if (MRISreadCanonicalCoordinates(mris, "sphere") != NO_ERROR)
{
ErrorExit(ERROR_NOFILE,
"%s: could not read canonical coordinates from ?h.sphere",
Progname);
}
MRISsaveVertexPositions(mris, ORIGINAL_VERTICES) ;
MRISrestoreVertexPositions(mris, CANONICAL_VERTICES) ;
MRIScomputeMetricProperties(mris) ;
ratio = mris->orig_area / M_PI * mris->radius * mris->radius * 4.0 ;
ratio = mris->orig_area / mris->total_area ;
MRISscaleBrain(mris, mris, sqrt(ratio)) ;
MRISsaveVertexPositions(mris, CANONICAL_VERTICES) ;
MRISrestoreVertexPositions(mris, ORIGINAL_VERTICES) ;
MRIScomputeMetricProperties(mris) ;
MRIScomputeNeighbors(mris, max_mm) ;
}
if (param_file)
{
MRI_SP *mrisp ;
mrisp = MRISPread(param_file) ;
if (normalize_param)
{
MRISnormalizeFromParameterization(mrisp, mris, param_no) ;
}
else
{
MRISfromParameterization(mrisp, mris, param_no) ;
}
MRISPfree(&mrisp) ;
if (normalize)
{
MRISnormalizeCurvature(mris,which_norm) ;
}
sprintf(fname, "%s/%s%s.param", path,name,suffix) ;
fprintf(stderr, "writing parameterized curvature to %s...", fname) ;
MRISwriteCurvature(mris, fname) ;
fprintf(stderr, "done.\n") ;
}
else
{
MRIScomputeSecondFundamentalFormThresholded(mris, cthresh) ;
nhandles = nint(1.0 - mris->Ktotal / (4.0*M_PI)) ;
fprintf(stderr, "total integrated curvature = %2.3f*4pi (%2.3f) --> "
"%d handles\n", (float)(mris->Ktotal/(4.0f*M_PI)),
(float)mris->Ktotal, nhandles) ;
#if 0
fprintf(stderr, "0: k1 = %2.3f, k2 = %2.3f, H = %2.3f, K = %2.3f\n",
mris->vertices[0].k1, mris->vertices[0].k2,
mris->vertices[0].H, mris->vertices[0].K) ;
fprintf(stderr, "0: vnum = %d, v2num = %d, total=%d, area=%2.3f\n",
mris->vertices[0].vnum, mris->vertices[0].v2num,
mris->vertices[0].vtotal,mris->vertices[0].area) ;
#endif
MRIScomputeCurvatureIndices(mris, &ici, &fi);
var = MRIStotalVariation(mris) ;
fprintf(stderr,"ICI = %2.1f, FI = %2.1f, variation=%2.3f\n", ici, fi, var);
if (diff_flag)
{
MRISuseCurvatureDifference(mris) ;
MRISaverageCurvatures(mris, navgs) ;
sprintf(fname, "%s/%s%s.diff", path,name,suffix) ;
fprintf(stderr, "writing curvature difference to %s...", fname) ;
MRISwriteCurvature(mris, fname) ;
fprintf(stderr, "done.\n") ;
}
if (ratio_flag)
{
MRISuseCurvatureRatio(mris) ;
MRISaverageCurvatures(mris, navgs) ;
if (normalize)
{
MRISnormalizeCurvature(mris,which_norm) ;
}
sprintf(fname, "%s/%s%s.ratio", path,name,suffix) ;
fprintf(stderr, "writing curvature ratio to %s...", fname) ;
MRISwriteCurvature(mris, fname) ;
fprintf(stderr, "done.\n") ;
}
if (contrast_flag)
{
MRISuseCurvatureContrast(mris) ;
MRISaverageCurvatures(mris, navgs) ;
if (normalize)
{
MRISnormalizeCurvature(mris,which_norm) ;
}
sprintf(fname, "%s/%s%s.contrast", path,name,suffix) ;
fprintf(stderr, "writing curvature contrast to %s...", fname) ;
MRISwriteCurvature(mris, fname) ;
fprintf(stderr, "done.\n") ;
}
if (neg_flag)
{
int neg ;
if (mris->patch)
{
mris->status = MRIS_PLANE ;
}
MRIScomputeMetricProperties(mris) ;
neg = MRIScountNegativeTriangles(mris) ;
MRISuseNegCurvature(mris) ;
MRISaverageCurvatures(mris, navgs) ;
sprintf(fname, "%s/%s%s.neg", path,name,suffix) ;
fprintf(stderr, "writing negative vertex curvature to %s...", fname) ;
MRISwriteCurvature(mris, fname) ;
fprintf(stderr, "%d negative triangles\n", neg) ;
fprintf(stderr, "done.\n") ;
{
int vno, fno ;
VERTEX *v ;
FACE *f ;
for (vno = 0 ; vno < mris->nvertices ; vno++)
{
v = &mris->vertices[vno] ;
if (v->ripflag)
{
continue ;
}
neg = 0 ;
for (fno = 0 ; fno < v->num ; fno++)
{
f = &mris->faces[v->f[fno]] ;
if (f->area < 0.0f)
{
neg = 1 ;
}
}
if (neg)
{
fprintf(stdout, "%d\n", vno) ;
}
}
}
}
if (max_flag)
{
MRISuseCurvatureMax(mris) ;
MRISaverageCurvatures(mris, navgs) ;
if (normalize)
{
MRISnormalizeCurvature(mris,which_norm) ;
}
sprintf(fname, "%s/%s%s.max", path,name,suffix) ;
fprintf(stderr, "writing curvature maxima to %s...", fname) ;
MRISwriteCurvature(mris, fname) ;
fprintf(stderr, "done.\n") ;
}
if (min_flag)
{
MRISuseCurvatureMin(mris) ;
MRISaverageCurvatures(mris, navgs) ;
if (normalize)
{
MRISnormalizeCurvature(mris,which_norm) ;
}
sprintf(fname, "%s/%s%s.min", path,name,suffix) ;
fprintf(stderr, "writing curvature minima to %s...", fname) ;
MRISwriteCurvature(mris, fname) ;
fprintf(stderr, "done.\n") ;
}
if (stretch_flag)
{
MRISreadOriginalProperties(mris, NULL) ;
MRISuseCurvatureStretch(mris) ;
MRISaverageCurvatures(mris, navgs) ;
if (normalize)
{
MRISnormalizeCurvature(mris,which_norm) ;
}
sprintf(fname, "%s/%s%s.stretch", path,name,suffix) ;
fprintf(stderr, "writing curvature stretch to %s...", fname) ;
MRISwriteCurvature(mris, fname) ;
fprintf(stderr, "done.\n") ;
}
if (write_flag)
{
MRISuseGaussianCurvature(mris) ;
if (cthresh > 0)
{
MRIShistoThresholdCurvature(mris, cthresh) ;
}
MRISaverageCurvatures(mris, navgs) ;
sprintf(fname, "%s/%s%s.K", path,name, suffix) ;
fprintf(stderr, "writing Gaussian curvature to %s...", fname) ;
if (normalize)
{
MRISnormalizeCurvature(mris,which_norm) ;
}
MRISwriteCurvature(mris, fname) ;
MRISuseMeanCurvature(mris) ;
if (cthresh > 0)
{
MRIShistoThresholdCurvature(mris, cthresh) ;
}
MRISaverageCurvatures(mris, navgs) ;
if (normalize)
{
MRISnormalizeCurvature(mris,which_norm) ;
}
sprintf(fname, "%s/%s%s.H", path,name, suffix) ;
fprintf(stderr, "done.\nwriting mean curvature to %s...", fname) ;
MRISwriteCurvature(mris, fname) ;
fprintf(stderr, "done.\n") ;
}
}
exit(0) ;
return(0) ; /* for ansi */
}
int
main(int argc, char *argv[]) {
char **av, in_surf_fname[STRLEN], *in_patch_fname, *out_patch_fname, hemi[STRLEN] ;
int ac, nargs;
char path[STRLEN], out_surf_fname[STRLEN], *cp ;
int msec, minutes, seconds ;
struct timeb start ;
MRI_SURFACE *mris_in, *mris_out ;
/* rkt: check for and handle version tag */
nargs = handle_version_option (argc, argv, "$Id: mris_map_cuts.c,v 1.3 2011/03/02 00:04:33 nicks Exp $", "$Name: $");
if (nargs && argc - nargs == 1)
exit (0);
argc -= nargs;
Progname = argv[0] ;
ErrorInit(NULL, NULL, NULL) ;
DiagInit(NULL, NULL, NULL) ;
TimerStart(&start) ;
ac = argc ;
av = argv ;
for ( ; argc > 1 && ISOPTION(*argv[1]) ; argc--, argv++) {
nargs = get_option(argc, argv) ;
argc -= nargs ;
argv += nargs ;
}
if (argc < 3)
usage_exit(1) ;
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") ;
sprintf(in_surf_fname, "%s/%s.%s", path, hemi, orig_surf_name) ;
FileNamePath(out_patch_fname, path) ;
cp = strrchr(out_patch_fname, '/') ;
if (!cp)
cp = out_patch_fname ;
cp = strchr(cp, '.') ;
if (cp)
{
strncpy(hemi, cp-2, 2) ;
hemi[2] = 0 ;
}
else
strcpy(hemi, "lh") ;
sprintf(out_surf_fname, "%s/%s.%s", path, hemi, orig_surf_name) ;
mris_in = MRISread(in_surf_fname) ;
mris_out = MRISread(out_surf_fname) ;
MRISsaveVertexPositions(mris_in, CANONICAL_VERTICES) ;
MRISsaveVertexPositions(mris_out, CANONICAL_VERTICES) ;
if (MRISreadVertexPositions(mris_out, inf_surf_name) != NO_ERROR)
ErrorExit(ERROR_BADPARM, "%s: could not inflated surface %s",
Progname, inf_surf_name) ;
if (MRISreadPatch(mris_in, in_patch_fname) != NO_ERROR)
ErrorExit(ERROR_BADPARM, "%s: could not read patch file %s",
Progname, in_patch_fname) ;
MRISmapCuts(mris_in, mris_out) ;
if (dilate)
{
printf("dilating patch %d times\n", dilate) ;
MRISdilateRipped(mris_out, dilate) ;
printf("%d valid vertices (%2.1f %% of total)\n",
MRISvalidVertices(mris_out), 100.0*MRISvalidVertices(mris_out)/mris_out->nvertices) ;
}
printf("writing output to %s\n", out_patch_fname) ;
MRISwritePatch(mris_out, out_patch_fname) ;
msec = TimerStop(&start) ;
seconds = nint((float)msec/1000.0f) ;
minutes = seconds / 60 ;
seconds = seconds % 60 ;
fprintf(stderr, "cut mapping took %d minutes"
" and %d seconds.\n", minutes, seconds) ;
exit(0) ;
return(0) ;
}
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 */
}
int
main(int argc, char *argv[]) {
char **av, *in_fname, *out_fname, path[STRLEN], fname[STRLEN],
hemi[STRLEN], *cp ;
int ac, nargs ;
MRI_SURFACE *mris ;
/* rkt: check for and handle version tag */
nargs = handle_version_option (argc, argv, "$Id: mris_reverse.c,v 1.10 2011/03/02 00:04:33 nicks Exp $", "$Name: $");
if (nargs && argc - nargs == 1)
exit (0);
argc -= nargs;
Progname = argv[0] ;
ErrorInit(NULL, NULL, NULL) ;
DiagInit(NULL, NULL, NULL) ;
ac = argc ;
av = argv ;
for ( ; argc > 1 && ISOPTION(*argv[1]) ; argc--, argv++) {
nargs = get_option(argc, argv) ;
argc -= nargs ;
argv += nargs ;
}
if (argc < 3)
usage_exit() ;
in_fname = argv[1] ;
out_fname = argv[2] ;
if (patch_flag) {
FileNamePath(in_fname, path) ;
FileNameOnly(in_fname, hemi) ;
cp = strchr(hemi, '.') ;
if (cp)
*cp = 0 ;
else
ErrorExit(ERROR_BADPARM, "%s: could not scan hemisphere from %s\n",
in_fname) ;
sprintf(fname, "%s/%s.%s", path, hemi, ORIG_NAME) ;
mris = MRISread(fname) ;
if (!mris)
ErrorExit(ERROR_NOFILE, "%s: could not read surface file %s",
Progname, fname) ;
if (MRISreadPatch(mris, in_fname) != NO_ERROR)
ErrorExit(Gerror, "%s: could not read patch\n", Progname) ;
} else {
mris = MRISread(in_fname) ;
if (!mris)
ErrorExit(ERROR_NOFILE, "%s: could not read surface file %s",
Progname, in_fname) ;
}
FileNamePath(out_fname, path) ;
MRISreverse(mris, which, 1) ;
if (Gdiag & DIAG_SHOW)
fprintf(stderr, "writing reversed surface to %s\n", out_fname) ;
mris->type = MRIS_TRIANGULAR_SURFACE ;
if (patch_flag)
MRISwritePatch(mris, out_fname) ;
else
MRISwrite(mris, out_fname) ;
exit(0) ;
return(0) ; /* for ansi */
}
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 */
}
