CLUSTER *
MRISclusterKMeans(MRI_SURFACE *mris, MRI *mri_profiles, int k, char *start_fname, MRI_SURFACE *mris_ico) {
int i, nsamples, iter, done, nchanged ;
char fname[STRLEN] ;
CLUSTER *ct ;
nsamples = mri_profiles->nframes ;
ct = calloc(k, sizeof(CLUSTER)) ;
for (i = 0 ; i < k ; i++) {
ct[i].v_mean = VectorAlloc(nsamples, MATRIX_REAL) ;
ct[i].m_cov = MatrixIdentity(nsamples, NULL) ;
ct[i].npoints = 0 ;
}
initialize_kmeans_centers(mris, mri_profiles, ct, k) ;
done = iter = 0 ;
do {
nchanged = mark_clusters(mris, mri_profiles, ct, k) ;
if (nchanged == 0)
done = 1 ;
compute_cluster_statistics(mris, mri_profiles, ct, k) ;
sprintf(fname, "%s.clusters%6.6d.annot",
mris->hemisphere == LEFT_HEMISPHERE ? "lh" : "rh", iter) ;
printf("%6.6d: writing %s\n", iter, fname) ;
MRISwriteAnnotation(mris, fname) ;
sprintf(fname, "./%s.clusters%6.6d.indices",
mris->hemisphere == LEFT_HEMISPHERE ? "lh" : "rh", iter) ;
MRISwriteCurvature(mris, fname) ;
if (iter++ > max_iterations)
done = 1 ;
} while (!done) ;
return(ct) ;
}
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_fname, *out_fname, *surf_fname ;
int ac, nargs, vno, nlabels, lno ;
MRI_SURFACE *mris ;
VERTEX *v ;
LABEL **label_array ;
/* rkt: check for and handle version tag */
nargs = handle_version_option (argc, argv, "$Id: mris_segment_vals.c,v 1.5 2011/03/02 00:04:34 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 < 4)
print_help() ;
surf_fname = argv[1] ;
in_fname = argv[2] ;
out_fname = argv[3] ;
mris = MRISread(surf_fname) ;
if (!mris)
ErrorExit(ERROR_NOFILE, "%s: could not read surface file %s",
Progname, surf_fname) ;
if (MRISreadValues(mris, in_fname) != NO_ERROR)
ErrorExit(ERROR_NOFILE, "%s: could not read val file %s",
Progname, in_fname) ;
MRISclearMarks(mris) ;
for (vno = 0 ; vno < mris->nvertices ; vno++) {
v = &mris->vertices[vno] ;
if (v->ripflag || fabs(v->val)<=thresh)
continue ;
v->marked = 1 ;
}
MRISsegmentMarked(mris, &label_array, &nlabels, area_thresh) ;
printf("%d labels found...\n", nlabels) ;
MRISsetVals(mris, 0) ;
for (lno = 0 ; lno < nlabels ; lno++) {
for (vno = 0 ; vno < label_array[lno]->n_points ; vno++) {
v = &mris->vertices[label_array[lno]->lv[vno].vno] ;
v->curv = lno+1 ;
}
}
fprintf(stderr, "writing segmented vals to %s\n", out_fname) ;
MRISwriteCurvature(mris, out_fname) ;
exit(0) ;
return(0) ; /* for ansi */
}
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)
{
int c,r,s,f;
double val,rval;
FILE *fp;
MRI *mritmp;
Progname = argv[0] ;
argc --;
argv++;
ErrorInit(NULL, NULL, NULL) ;
DiagInit(NULL, NULL, NULL) ;
/* assign default geometry */
cdircos[0] = 1.0;
cdircos[1] = 0.0;
cdircos[2] = 0.0;
rdircos[0] = 0.0;
rdircos[1] = 1.0;
rdircos[2] = 0.0;
sdircos[0] = 0.0;
sdircos[1] = 0.0;
sdircos[2] = 1.0;
res[0] = 1.0;
res[1] = 1.0;
res[2] = 1.0;
cras[0] = 0.0;
cras[1] = 0.0;
cras[2] = 0.0;
res[3] = 2.0; /* TR */
if (argc == 0) usage_exit();
parse_commandline(argc, argv);
check_options();
dump_options(stdout);
if(tempid != NULL) {
printf("INFO: reading template header\n");
if(! DoCurv) mritemp = MRIreadHeader(tempid,tempfmtid);
else mritemp = MRIread(tempid);
if (mritemp == NULL) {
printf("ERROR: reading %s header\n",tempid);
exit(1);
}
if(NewVoxSizeSpeced){
dim[0] = round(mritemp->width*mritemp->xsize/res[0]);
dim[1] = round(mritemp->height*mritemp->ysize/res[1]);
dim[2] = round(mritemp->depth*mritemp->zsize/res[2]);
dim[3] = mritemp->nframes;
res[3] = mritemp->tr;
dimSpeced = 1;
}
if(dimSpeced){
mritmp = MRIallocSequence(dim[0],dim[1],dim[2],MRI_FLOAT,dim[3]);
MRIcopyHeader(mritemp,mritmp);
MRIfree(&mritemp);
mritemp = mritmp;
}
if(resSpeced){
mritemp->xsize = res[0];
mritemp->ysize = res[1];
mritemp->zsize = res[2];
mritemp->tr = res[3];
}
dim[0] = mritemp->width;
dim[1] = mritemp->height;
dim[2] = mritemp->depth;
if (nframes > 0) dim[3] = nframes;
else dim[3] = mritemp->nframes;
mritemp->nframes = dim[3];
}
if(mritemp) {
if(SpikeTP >= mritemp->nframes){
printf("ERROR: SpikeTP = %d >= mritemp->nframes = %d\n",
SpikeTP,mritemp->nframes);
exit(1);
}
}
printf("Synthesizing\n");
srand48(seed);
if (strcmp(pdfname,"gaussian")==0)
mri = MRIrandn(dim[0], dim[1], dim[2], dim[3], gausmean, gausstd, NULL);
else if (strcmp(pdfname,"uniform")==0)
mri = MRIdrand48(dim[0], dim[1], dim[2], dim[3], 0, 1, NULL);
else if (strcmp(pdfname,"const")==0)
mri = MRIconst(dim[0], dim[1], dim[2], dim[3], ValueA, NULL);
else if (strcmp(pdfname,"sphere")==0) {
if(voxradius < 0)
voxradius =
sqrt( pow(dim[0]/2.0,2)+pow(dim[1]/2.0,2)+pow(dim[2]/2.0,2) )/2.0;
printf("voxradius = %lf\n",voxradius);
mri = MRIsphereMask(dim[0], dim[1], dim[2], dim[3],
dim[0]/2.0, dim[1]/2.0, dim[2]/2.0,
voxradius, ValueA, NULL);
} else if (strcmp(pdfname,"delta")==0) {
mri = MRIconst(dim[0], dim[1], dim[2], dim[3], delta_off_value, NULL);
if (delta_crsf_speced == 0) {
delta_crsf[0] = dim[0]/2;
delta_crsf[1] = dim[1]/2;
delta_crsf[2] = dim[2]/2;
delta_crsf[3] = dim[3]/2;
}
printf("delta set to %g at %d %d %d %d\n",delta_value,delta_crsf[0],
delta_crsf[1],delta_crsf[2],delta_crsf[3]);
MRIFseq_vox(mri,
delta_crsf[0],
delta_crsf[1],
delta_crsf[2],
delta_crsf[3]) = delta_value;
} else if (strcmp(pdfname,"chi2")==0) {
rfs = RFspecInit(seed,NULL);
rfs->name = strcpyalloc("chi2");
rfs->params[0] = dendof;
mri = MRIconst(dim[0], dim[1], dim[2], dim[3], 0, NULL);
printf("Synthesizing chi2 with dof=%d\n",dendof);
RFsynth(mri,rfs,NULL);
} else if (strcmp(pdfname,"z")==0) {
printf("Synthesizing z \n");
rfs = RFspecInit(seed,NULL);
rfs->name = strcpyalloc("gaussian");
rfs->params[0] = 0; // mean
rfs->params[1] = 1; // std
mri = MRIconst(dim[0], dim[1], dim[2], dim[3], 0, NULL);
RFsynth(mri,rfs,NULL);
} else if (strcmp(pdfname,"t")==0) {
printf("Synthesizing t with dof=%d\n",dendof);
rfs = RFspecInit(seed,NULL);
rfs->name = strcpyalloc("t");
rfs->params[0] = dendof;
mri = MRIconst(dim[0], dim[1], dim[2], dim[3], 0, NULL);
RFsynth(mri,rfs,NULL);
} else if (strcmp(pdfname,"tr")==0) {
printf("Synthesizing t with dof=%d as ratio of z/sqrt(chi2)\n",dendof);
rfs = RFspecInit(seed,NULL);
// numerator
rfs->name = strcpyalloc("gaussian");
rfs->params[0] = 0; // mean
rfs->params[1] = 1; // std
mri = MRIconst(dim[0], dim[1], dim[2], dim[3], 0, NULL);
RFsynth(mri,rfs,NULL);
// denominator
rfs->name = strcpyalloc("chi2");
rfs->params[0] = dendof;
mri2 = MRIconst(dim[0], dim[1], dim[2], dim[3], 0, NULL);
RFsynth(mri2,rfs,NULL);
fMRIsqrt(mri2,mri2); // sqrt of chi2
mri = MRIdivide(mri,mri2,mri);
MRIscalarMul(mri, mri, sqrt(dendof)) ;
MRIfree(&mri2);
} else if (strcmp(pdfname,"F")==0) {
printf("Synthesizing F with num=%d den=%d\n",numdof,dendof);
rfs = RFspecInit(seed,NULL);
rfs->name = strcpyalloc("F");
rfs->params[0] = numdof;
rfs->params[1] = dendof;
mri = MRIconst(dim[0], dim[1], dim[2], dim[3], 0, NULL);
RFsynth(mri,rfs,NULL);
} else if (strcmp(pdfname,"Fr")==0) {
printf("Synthesizing F with num=%d den=%d as ratio of two chi2\n",
numdof,dendof);
rfs = RFspecInit(seed,NULL);
rfs->name = strcpyalloc("chi2");
// numerator
rfs->params[0] = numdof;
mri = MRIconst(dim[0], dim[1], dim[2], dim[3], 0, NULL);
RFsynth(mri,rfs,NULL);
// denominator
rfs->params[0] = dendof;
mri2 = MRIconst(dim[0], dim[1], dim[2], dim[3], 0, NULL);
RFsynth(mri2,rfs,NULL);
mri = MRIdivide(mri,mri2,mri);
MRIscalarMul(mri, mri, (double)dendof/numdof) ;
MRIfree(&mri2);
} else if (strcmp(pdfname,"voxcrs")==0) {
// three frames. 1st=col, 2nd=row, 3rd=slice
printf("Filling with vox CRS\n");
mri = MRIconst(dim[0], dim[1], dim[2], 3, 0, NULL);
for(c=0; c < mri->width; c ++){
for(r=0; r < mri->height; r ++){
for(s=0; s < mri->depth; s ++){
MRIsetVoxVal(mri,c,r,s,0,c);
MRIsetVoxVal(mri,c,r,s,1,r);
MRIsetVoxVal(mri,c,r,s,2,s);
}
}
}
} else if (strcmp(pdfname,"boundingbox")==0) {
printf("Setting bounding box \n");
if(mritemp == NULL)
mritemp = MRIconst(dim[0], dim[1], dim[2], dim[3], 0, NULL);
mri = MRIsetBoundingBox(mritemp,&boundingbox,ValueA,ValueB);
if(!mri) exit(1);
}
else if (strcmp(pdfname,"checker")==0) {
printf("Checker \n");
mri=MRIchecker(mritemp,NULL);
if(!mri) exit(1);
}
else if (strcmp(pdfname,"sliceno")==0) {
printf("SliceNo \n");
if(mritemp == NULL){
printf("ERROR: need --temp with sliceno\n");
exit(1);
}
mri=MRIsliceNo(mritemp,NULL);
if(!mri) exit(1);
}
else if (strcmp(pdfname,"indexno")==0) {
printf("IndexNo \n");
if(mritemp == NULL){
printf("ERROR: need --temp with indexno\n");
exit(1);
}
mri=MRIindexNo(mritemp,NULL);
if(!mri) exit(1);
}
else if (strcmp(pdfname,"crs")==0) {
printf("CRS \n");
if(mritemp == NULL){
printf("ERROR: need --temp with crs\n");
exit(1);
}
mri=MRIcrs(mritemp,NULL);
if(!mri) exit(1);
}
else {
printf("ERROR: pdf %s unrecognized, must be gaussian, uniform,\n"
"const, delta, checker\n", pdfname);
exit(1);
}
if (tempid != NULL) {
MRIcopyHeader(mritemp,mri);
mri->type = MRI_FLOAT;
// Override
if(nframes > 0) mri->nframes = nframes;
if(TR > 0) mri->tr = TR;
} else {
if(mri == NULL) {
usage_exit();
}
mri->xsize = res[0];
mri->ysize = res[1];
mri->zsize = res[2];
mri->tr = res[3];
mri->x_r = cdircos[0];
mri->x_a = cdircos[1];
mri->x_s = cdircos[2];
mri->y_r = rdircos[0];
mri->y_a = rdircos[1];
mri->y_s = rdircos[2];
mri->z_r = sdircos[0];
mri->z_a = sdircos[1];
mri->z_s = sdircos[2];
if(!usep0){
mri->c_r = cras[0];
mri->c_a = cras[1];
mri->c_s = cras[2];
}
else MRIp0ToCRAS(mri, p0[0], p0[1], p0[2]);
}
if (gstd > 0) {
if(!UseFFT){
printf("Smoothing\n");
MRIgaussianSmooth(mri, gstd, gmnnorm, mri); /* gmnnorm = 1 = normalize */
}
else {
printf("Smoothing with FFT \n");
mri2 = MRIcopy(mri,NULL);
mri = MRI_fft_gaussian(mri2, mri,
gstd, gmnnorm); /* gmnnorm = 1 = normalize */
}
if (rescale) {
printf("Rescaling\n");
if (strcmp(pdfname,"z")==0) RFrescale(mri,rfs,NULL,mri);
if (strcmp(pdfname,"chi2")==0) RFrescale(mri,rfs,NULL,mri);
if (strcmp(pdfname,"t")==0) RFrescale(mri,rfs,NULL,mri);
if (strcmp(pdfname,"tr")==0) RFrescale(mri,rfs,NULL,mri);
if (strcmp(pdfname,"F")==0) RFrescale(mri,rfs,NULL,mri);
if (strcmp(pdfname,"Fr")==0) RFrescale(mri,rfs,NULL,mri);
}
}
if(DoHSC){
// This multiplies each frame by a random number
// between HSCMin HSCMax to simulate heteroscedastisity
printf("Applying HSC %lf %lf\n",HSCMin,HSCMax);
for(f=0; f < mri->nframes; f++){
rval = (HSCMax-HSCMin)*drand48() + HSCMin;
if(debug) printf("%3d %lf\n",f,rval);
for(c=0; c < mri->width; c ++){
for(r=0; r < mri->height; r ++){
for(s=0; s < mri->depth; s ++){
val = MRIgetVoxVal(mri,c,r,s,f);
MRIsetVoxVal(mri,c,r,s,f,rval*val);
}
}
}
}
}
if(AddOffset) {
printf("Adding offset\n");
offset = MRIread(tempid);
if(offset == NULL) exit(1);
if(OffsetFrame == -1) OffsetFrame = nint(offset->nframes/2);
printf("Offset frame %d\n",OffsetFrame);
mritmp = fMRIframe(offset, OffsetFrame, NULL);
if(mritmp == NULL) exit(1);
MRIfree(&offset);
offset = mritmp;
fMRIaddOffset(mri, offset, NULL, mri);
}
if(SpikeTP > 0){
printf("Spiking time point %d\n",SpikeTP);
for(c=0; c < mri->width; c ++){
for(r=0; r < mri->height; r ++){
for(s=0; s < mri->depth; s ++){
MRIsetVoxVal(mri,c,r,s,SpikeTP,1e9);
}
}
}
}
if(DoAbs){
printf("Computing absolute value\n");
MRIabs(mri,mri);
}
if(!NoOutput){
printf("Saving\n");
if(!DoCurv) MRIwriteAnyFormat(mri,volid,volfmt,-1,NULL);
else {
printf("Saving in curv format\n");
MRIScopyMRI(surf, mri, 0, "curv");
MRISwriteCurvature(surf,volid);
}
}
if(sum2file){
val = MRIsum2All(mri);
fp = fopen(sum2file,"w");
if(fp == NULL){
printf("ERROR: opening %s\n",sum2file);
exit(1);
}
printf("sum2all: %20.10lf\n",val);
printf("vrf: %20.10lf\n",1/val);
fprintf(fp,"%20.10lf\n",val);
}
return(0);
}
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[]) {
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;
}
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_fname, *out_fname, fname[STRLEN], path[STRLEN] ;
int ac, nargs, start_t, pass ;
MRI_SURFACE *mris ;
char cmdline[CMD_LINE_LEN] ;
make_cmd_version_string
(argc, argv,
"$Id: mris_smooth.c,v 1.28 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_smooth.c,v 1.28 2011/03/02 00:04:34 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)
{
print_help() ;
}
in_fname = argv[1] ;
out_fname = argv[2] ;
FileNamePath(out_fname, path) ;
mris = MRISfastRead(in_fname) ;
if (!mris)
ErrorExit(ERROR_NOFILE, "%s: could not read surface file %s",
Progname, in_fname) ;
MRISaddCommandLine(mris, cmdline) ;
MRISremoveTriangleLinks(mris) ;
fprintf(stderr, "smoothing surface tessellation for %d iterations...\n",
niterations);
MRIScomputeMetricProperties(mris) ;
MRISstoreMetricProperties(mris) ;
MRISsetNeighborhoodSize(mris, nbrs) ;
#define DT 0.5
if (gaussian_norm > 0)
{
int i, done, start_avgs = gaussian_avgs, j ;
done = 0;
start_t = 0 ;
pass = 0 ;
do
{
for (i = start_t ; i < niterations+start_t ; i++)
{
MRIScomputeMetricProperties(mris) ;
MRISsaveVertexPositions(mris, TMP_VERTICES) ;
for (j = 0 ; j < 5 ; j++)
{
MRISaverageVertexPositions(mris, 2) ; // turn flat spikes into tubular ones
MRIScomputeMetricProperties(mris) ;
MRIScomputeSecondFundamentalForm(mris) ;
MRIShistoThresholdGaussianCurvatureToMarked(mris, (float)(mris->nvertices-20)/mris->nvertices) ;
}
MRISrestoreVertexPositions(mris, TMP_VERTICES) ;
MRIScomputeMetricProperties(mris) ;
MRISsmoothSurfaceNormals(mris, gaussian_avgs) ;
MRISclearMarks(mris) ;
MRISthresholdGaussianCurvatureToMarked(mris, 10, 50);
MRIScomputeSecondFundamentalForm(mris) ;
MRIShistoThresholdGaussianCurvatureToMarked(mris, (float)(mris->nvertices-20)/mris->nvertices) ;
MRISthresholdGaussianCurvatureToMarked(mris, 10, 50);
if ((write_iterations > 0) && ((i % write_iterations) == 0))
{
char fname[STRLEN] ;
sprintf(fname, "%s%04d", out_fname, i) ;
printf("writing snapshot to %s...\n", fname) ;
MRISwrite(mris, fname) ;
if (Gdiag & DIAG_WRITE)
{
MRISuseGaussianCurvature(mris) ;
sprintf(fname, "%s_K%04d", out_fname, i) ;
printf("writing curvature to %s...\n", fname) ;
MRISwriteCurvature(mris, fname) ;
sprintf(fname, "%s_marked%04d", out_fname, i) ;
printf("writing marks to %s...\n", fname) ;
MRISwriteMarked(mris, fname) ;
}
}
for (j = 0 ; j <= 5*nint(1/DT) ; j++)
{
MRISmarkedSpringTerm(mris, l_spring) ;
MRISaverageGradients(mris, gaussian_avgs) ;
MRISmomentumTimeStep(mris, momentum, DT, 1, gaussian_avgs) ;
MRISclearGradient(mris) ;
MRIScomputeMetricProperties(mris) ;
MRISsmoothSurfaceNormals(mris, gaussian_avgs) ;
{
int vno ;
VERTEX *v ;
for (vno = 0 ; vno < mris->nvertices ; vno++)
{
v = &mris->vertices[vno] ;
if (v->marked > 0)
{
v->K = 1.0/(v->marked) ;
}
else
{
v->K = 0 ;
}
}
}
}
}
MRISclearGradient(mris) ;
if (gaussian_avgs == 2)
{
if (pass++ > 4)
{
done = 1 ;
}
else
{
int num = count_big_curvatures(mris, 2) ;
printf("------------------------------------------------------\n") ;
printf("------------------------------------------------------\n") ;
printf("------------------ pass %d (num=%d) ------------------\n",
pass, num) ;
printf("------------------------------------------------------\n") ;
printf("------------------------------------------------------\n") ;
gaussian_avgs = start_avgs ;
}
}
else
{
gaussian_avgs /= 2 ;
if (done ==0)
{
printf("----------------- setting avgs to %d -----------------\n", gaussian_avgs) ;
}
}
start_t = i ;
}
while (!done) ;
#if 0
// more smoothing with principal curvatures
gaussian_avgs = start_avgs ;
printf("--------------------------------------------------------------------------\n") ;
printf("--------------------------------------------------------------------------\n") ;
printf("---------------------- starting threshold smoothing ----------------------\n") ;
printf("--------------------------------------------------------------------------\n") ;
printf("--------------------------------------------------------------------------\n") ;
do
{
for (i = start_t ; i < niterations+start_t ; i++)
{
MRIScomputeMetricProperties(mris) ;
MRIScomputeSecondFundamentalForm(mris) ;
MRISsmoothSurfaceNormals(mris, 16) ;
#define KTHRESH 1.5 // everything with kmin less than this will not move
MRISthresholdPrincipalCurvatures(mris, KTHRESH) ;
MRISspringTermWithGaussianCurvature(mris, gaussian_norm, l_spring) ;
MRISaverageGradients(mris, gaussian_avgs) ;
MRISmomentumTimeStep(mris, 0, 0.1, 1, gaussian_avgs) ;
MRISclearGradient(mris) ;
if ((write_iterations > 0) && (((i+1) % write_iterations) == 0))
{
char fname[STRLEN] ;
sprintf(fname, "%s%04d", out_fname, i+1) ;
printf("writing snapshot to %s...\n", fname) ;
MRISwrite(mris, fname) ;
if (Gdiag & DIAG_WRITE/* && DIAG_VERBOSE_ON*/)
{
MRISuseGaussianCurvature(mris) ;
sprintf(fname, "%s_K%04d", out_fname, i+1) ;
printf("writing curvature to %s...\n", fname) ;
MRISwriteCurvature(mris, fname) ;
}
}
}
MRISclearGradient(mris) ;
done = (gaussian_avgs == 2) ;
gaussian_avgs /= 2 ;
if (done ==0)
{
printf("---------------------- setting avgs to %d ----------------------\n", gaussian_avgs) ;
}
start_t = i ;
}
while (!done) ;
#endif
}
else
{
MRISaverageVertexPositions(mris, niterations) ;
}
fprintf(stderr, "smoothing complete - recomputing first and second "
"fundamental forms...\n") ;
MRIScomputeMetricProperties(mris) ;
if (rescale)
{
MRISscaleBrainArea(mris) ;
}
MRIScomputeSecondFundamentalForm(mris) ;
MRISuseMeanCurvature(mris) ;
MRISaverageCurvatures(mris, navgs) ;
if (normalize_flag)
{
MRISnormalizeCurvature(mris, which_norm) ;
}
sprintf(fname, "%s.%s", mris->hemisphere == LEFT_HEMISPHERE?"lh":"rh",
curvature_fname);
if (no_write == 0)
{
fprintf(stderr, "writing smoothed curvature to %s/%s\n", path,fname) ;
MRISwriteCurvature(mris, fname) ;
sprintf(fname, "%s.%s", mris->hemisphere == LEFT_HEMISPHERE?"lh":"rh",
area_fname);
fprintf(stderr, "writing smoothed area to %s/%s\n", path, fname) ;
MRISwriteArea(mris, fname) ;
}
if (Gdiag & DIAG_SHOW)
{
fprintf(stderr, "writing smoothed surface to %s\n", out_fname) ;
}
MRISwrite(mris, out_fname) ;
exit(0) ;
return(0) ; /* for ansi */
}
