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