static int
segment_and_write_labels(char *subject, char *name, MRI_SURFACE *mris,
LABEL ***plabels, int *pnlabels, int offset,
float min_label_area) {
LABEL **labels, *area ;
int nlabels, i ;
char fname[STRLEN] ;
MRISsegmentMarked(mris, &labels, &nlabels, min_label_area) ;
for (i = 0 ; i < nlabels ; i++) {
area = labels[i] ;
strcpy(area->subject_name, subject) ;
#if 0
fprintf(stderr, "label %d: %d points, %2.1f mm\n",
i, area->n_points, LabelArea(area, mris)) ;
#endif
if (write_flag) {
sprintf(fname, "%s%d", name, i+offset) ;
fprintf(stderr, "writing label %s\n", fname) ;
LabelWrite(area, fname) ;
}
strcpy(area->name, name) ;
}
*pnlabels = nlabels ;
*plabels = labels ;
return(NO_ERROR) ;
}
/*--------------------------------------------------------------------*/
static int convert_single_path_to_label (char* fname, char* ofname) {
int err;
int num_paths;
PATH** paths = NULL;
LABEL* label = NULL;
int path_index;
/* 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 label file.\n"
"Maybe you didn't mean to use the single option?\n"
"Converting it to a single path.\n");
}
/* Convert our first path. */
err = PathConvertToLabel (paths[0], &label);
if (ERROR_NONE != err) {
for (path_index = 0; path_index < num_paths; path_index++)
PathFree (&paths[path_index]);
free (paths);
return err;
}
/* Delete all the paths. */
for (path_index = 0; path_index < num_paths; path_index++) {
PathFree (&paths[path_index]);
}
/* Free our paths variable. */
free (paths);
/* Write the label file. */
LabelWrite (label, ofname);
/* Free the label. */
LabelFree (&label);
return (ERROR_NONE);
}
int
main(int argc, char *argv[])
{
double thresh ;
MRI *mri, *mri_abs ;
char *out_stem, fname[STRLEN] ;
MRI_SEGMENTATION *mriseg ;
int s ;
LABEL *area ;
Progname = argv[0] ;
ErrorInit(NULL, NULL, NULL) ;
DiagInit(NULL, NULL, NULL) ;
mri = MRIread(argv[1]) ;
if (mri == NULL)
ErrorExit(ERROR_NOFILE, "%s: could not load MRI from %s\n", Progname, argv[1]) ;
if (use_abs)
mri_abs = MRIabs(mri, NULL) ;
else
mri_abs = MRIcopy(mri, NULL) ;
thresh = atof(argv[2]) ;
out_stem = argv[3] ;
mriseg = MRIsegment(mri, thresh, 1e10) ;
MRIremoveSmallSegments(mriseg, size_thresh) ;
printf("segmenting volume at threshold %2.1f yields %d segments\n", thresh, mriseg->nsegments) ;
for (s = 0 ; s < mriseg->nsegments ; s++)
{
area = MRIsegmentToLabel(mriseg, mri_abs, s) ;
sprintf(fname, "%s.%3.3d.label", out_stem, s) ;
LabelWrite(area, fname) ;
}
return(0) ;
}
int
main(int argc, char *argv[]) {
char **av, *hemi, *subject_name, *cp, fname[STRLEN];
char *parc_name, *annot_name ;
int ac, nargs, vno, i ;
MRI_SURFACE *mris ;
MRI *mri_parc ;
VERTEX *v ;
double d ;
Real x, y, z, xw, yw, zw ;
/* rkt: check for and handle version tag */
nargs = handle_version_option (argc, argv,
"$Id: mris_sample_parc.c,v 1.31 2016/12/11 14:33:38 fischl 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 < 4)
usage_exit() ;
subject_name = argv[1] ;
hemi = argv[2] ;
parc_name = argv[3] ;
annot_name = argv[4] ;
if (strlen(sdir) == 0) /* if not specified explicitly as option */
{
cp = getenv("SUBJECTS_DIR") ;
if (!cp)
ErrorExit(ERROR_BADPARM,
"%s: SUBJECTS_DIR not defined in environment.\n", Progname) ;
strcpy(sdir, cp) ;
}
if (parc_name[0] == '/') // full path specified
strcpy(fname, parc_name) ;
else
sprintf(fname, "%s/%s/mri/%s", sdir, subject_name, parc_name) ;
printf("reading parcellation volume from %s...\n", fname) ;
mri_parc = MRIread(fname) ;
if (!mri_parc)
ErrorExit(ERROR_NOFILE, "%s: could not read input volume %s",
Progname, fname) ;
if (mask_fname) {
MRI *mri_mask, *mri_tmp ;
mri_tmp = MRIread(mask_fname) ;
if (mri_tmp == NULL)
ErrorExit(ERROR_BADPARM, "%s: could not load mask volume %s", Progname, mask_fname) ;
mri_mask = MRIclone(mri_tmp, NULL) ;
MRIcopyLabel(mri_tmp, mri_mask, mask_val) ;
MRIdilate(mri_mask, mri_mask) ;
MRIdilate(mri_mask, mri_mask) ;
MRIdilate(mri_mask, mri_mask) ;
MRIdilate(mri_mask, mri_mask) ;
MRIfree(&mri_tmp) ;
mri_tmp = MRIclone(mri_parc, NULL) ;
MRIcopyLabeledVoxels(mri_parc, mri_mask, mri_tmp, mask_val) ;
MRIfree(&mri_parc) ;
mri_parc = mri_tmp ;
if (Gdiag & DIAG_WRITE && DIAG_VERBOSE_ON)
MRIwrite(mri_parc, "p.mgz") ;
MRIfree(&mri_mask) ;
}
for (i = 0 ; i < ntrans ; i++) {
MRIreplaceValues(mri_parc, mri_parc, trans_in[i], trans_out[i]) ;
}
sprintf(fname, "%s/%s/surf/%s.%s", sdir, subject_name, 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) ;
if (avgs > 0)
MRISaverageVertexPositions(mris, avgs) ;
if (FZERO(proj_mm)) {
if (MRISreadCurvatureFile(mris, thickness_name) != NO_ERROR)
ErrorExit(ERROR_NOFILE, "%s: could not read thickness file %s",
Progname, thickness_name) ;
}
if (color_table_fname) {
mris->ct = CTABreadASCII(color_table_fname) ;
if (mris->ct == NULL)
ErrorExit(ERROR_NOFILE, "%s: could not read color file %s",
Progname, color_table_fname) ;
}
if (sample_from_vol_to_surf) // sample from volume to surface */
{
MRIsampleParcellationToSurface(mris, mri_parc) ;
} else /* sample from surface to volume */
{
for (vno = 0 ; vno < mris->nvertices ; vno++) {
v = &mris->vertices[vno] ;
if (v->ripflag)
continue ;
if (vno == Gdiag_no)
DiagBreak() ;
if (!FZERO(proj_mm))
d = proj_mm ;
else
d = v->curv*proj_frac ; /* halfway out */
x = v->x+d*v->nx ;
y = v->y+d*v->ny ;
z = v->z+d*v->nz ;
MRIsurfaceRASToVoxel(mri_parc, x, y, z, &xw, &yw, &zw) ;
v->annotation = v->val =
MRIfindNearestNonzero(mri_parc, wsize, xw, yw, zw, ((float)wsize-1)/2) ;
if (v->val == 0xffffffff)
DiagBreak() ;
}
}
if (replace_label)
replace_vertices_with_label(mris, mri_parc, replace_label, proj_mm);
if (unknown_label >= 0) {
LABEL **labels, *label ;
int nlabels, i, biggest_label, most_vertices, nzero ;
#define TMP_LABEL 1000
for (nzero = vno = 0 ; vno < mris->nvertices ; vno++) {
v = &mris->vertices[vno] ;
if (v->annotation == 0) {
v->annotation = TMP_LABEL;
nzero++ ;
}
}
printf("%d unknown vertices found\n", nzero) ;
MRISsegmentAnnotated(mris, &labels, &nlabels, 10) ;
most_vertices = 0 ;
biggest_label = -1 ;
for (i = 0 ; i < nlabels ; i++) {
label = labels[i] ;
if (mris->vertices[label->lv[0].vno].annotation == TMP_LABEL) {
if (label->n_points > most_vertices) {
biggest_label = i ;
most_vertices = label->n_points ;
}
}
}
if (biggest_label >= 0) {
label = labels[biggest_label] ;
printf("replacing label # %d with %d vertices "
"(vno=%d) with label %d\n",
biggest_label,
label->n_points,
label->lv[0].vno,
unknown_label) ;
for (i = 0 ; i < label->n_points ; i++) {
v = &mris->vertices[label->lv[i].vno] ;
v->annotation = v->val = unknown_label ;
}
}
for (nzero = vno = 0 ; vno < mris->nvertices ; vno++) {
v = &mris->vertices[vno] ;
if (v->annotation == TMP_LABEL) {
v->annotation = 0;
nzero++ ;
}
}
printf("after replacement, %d unknown vertices found\n", nzero) ;
MRISmodeFilterZeroVals(mris) ; /* get rid of the rest
of the unknowns by mode filtering */
for (i = 0 ; i < nlabels ; i++)
LabelFree(&labels[i]) ;
free(labels) ;
}
MRIScopyValsToAnnotations(mris) ;
if (fix_topology != 0)
fix_label_topology(mris, fix_topology) ;
if (mode_filter) {
printf("mode filtering sample labels...\n") ;
#if 0
MRISmodeFilterZeroVals(mris) ;
#else
MRISmodeFilterVals(mris, mode_filter) ;
#endif
for (vno = 0 ; vno < mris->nvertices ; vno++) {
v = &mris->vertices[vno] ;
if (v->ripflag)
continue ;
v->annotation = v->val ;
}
}
/* this will fill in the v->annotation field from the v->val ones */
translate_indices_to_annotations(mris, translation_fname) ;
if (label_index >= 0)
{
int index ;
LABEL *area ;
printf("writing label to %s...\n", annot_name) ;
MRISclearMarks(mris) ;
for (vno = 0 ; vno < mris->nvertices ; vno++)
{
if (vno == Gdiag_no)
DiagBreak() ;
v = &mris->vertices[vno] ;
if (v->annotation > 0)
DiagBreak() ;
CTABfindAnnotation(mris->ct, v->annotation, &index);
if (index == label_index)
v->marked = 1 ;
}
area = LabelFromMarkedSurface(mris) ;
if (nclose > 0)
{
LabelDilate(area, mris, nclose, CURRENT_VERTICES) ;
LabelErode(area, mris, nclose) ;
}
LabelWrite(area, annot_name) ;
}
else
{
printf("writing annotation to %s...\n", annot_name) ;
MRISwriteAnnotation(mris, annot_name) ;
}
/* MRISreadAnnotation(mris, fname) ;*/
exit(0) ;
return(0) ; /* for ansi */
}
int
main(int argc, char *argv[])
{
char **av, *output_fname ;
int ac, nargs, msec, mode=-1 ;
LABEL *area = NULL ;
MRI_SURFACE *mris ;
struct timeb then ;
MRI *mri_dist ;
/* rkt: check for and handle version tag */
nargs = handle_version_option
(argc, argv,
"$Id: mris_distance_transform.c,v 1.5 2013/04/12 20:59:17 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) ;
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() ;
TimerStart(&then) ;
mris = MRISread(argv[1]) ;
if (mris == NULL)
ErrorExit(ERROR_NOFILE, "%s: could not read surface %s",
Progname, argv[1]) ;
if (vol)
{
/*
mri_template = MRIread(argv[2]) ;
if (!mri_template)
ErrorExit(ERROR_NOFILE, "%s: could not read MRI volume from %s\n", Progname, argv[2]) ;
*/
}
else
{
area = LabelRead(NULL, argv[2]) ;
if (area == NULL)
ErrorExit(ERROR_NOFILE, "%s: could not read label %s",
Progname, argv[2]) ;
if (anterior_dist > 0)
LabelCropAnterior(area, anterior_dist) ;
if (posterior_dist > 0)
LabelCropPosterior(area, posterior_dist) ;
}
if (stricmp(argv[3], "signed") == 0)
mode = DTRANS_MODE_SIGNED ;
else if (stricmp(argv[3], "unsigned") == 0)
mode = DTRANS_MODE_UNSIGNED ;
else if (stricmp(argv[3], "outside") == 0)
mode = DTRANS_MODE_OUTSIDE ;
else
{
print_usage() ;
ErrorExit(ERROR_BADPARM, "unrecognized mode choice %s\n", argv[3]) ;
}
output_fname = argv[4] ;
MRIScomputeMetricProperties(mris) ;
if (vol)
{
mri_dist = MRIScomputeDistanceToSurface(mris, NULL, 0.25) ;
MRIwrite(mri_dist, argv[4]) ;
}
else
{
MRIScomputeSecondFundamentalForm(mris) ;
if (normalize > 0)
{
normalize = sqrt(mris->total_area) ;
printf("normalizing surface distances by sqrt(%2.1f) = %2.1f\n", mris->total_area,normalize) ;
}
if (divide > 1)
{
int i ;
char fname[STRLEN], ext[STRLEN], base_name[STRLEN] ;
LABEL *area_division ;
FileNameExtension(output_fname, ext) ;
FileNameRemoveExtension(output_fname, base_name) ;
LabelMark(area, mris) ;
MRIScopyMarksToAnnotation(mris) ;
MRISsaveVertexPositions(mris, TMP_VERTICES) ;
if (MRISreadVertexPositions(mris, divide_surf_name) != NO_ERROR)
ErrorExit(ERROR_BADPARM, "%s: could not read vertex coords from %s", Progname, divide_surf_name) ;
MRIScomputeSecondFundamentalForm(mris) ;
MRISdivideAnnotationUnit(mris, 1, divide) ;
MRISrestoreVertexPositions(mris, TMP_VERTICES) ;
MRIScomputeSecondFundamentalForm(mris) ;
// MRISdivideAnnotationUnit sets the marked to be in [0,divide-1], make it [1,divide]
// make sure they are oriented along original a/p direction
#define MAX_UNITS 100
{
double cx[MAX_UNITS], cy[MAX_UNITS], cz[MAX_UNITS], min_a ;
int index, num[MAX_UNITS], new_index[MAX_UNITS], j, min_i ;
VERTEX *v ;
memset(num, 0, sizeof(num[0])*divide) ;
memset(cx, 0, sizeof(cx[0])*divide) ;
memset(cy, 0, sizeof(cy[0])*divide) ;
memset(cz, 0, sizeof(cz[0])*divide) ;
for (i = 0 ; i < area->n_points ; i++)
{
if (area->lv[i].vno < 0 || area->lv[i].deleted > 0)
continue ;
v = &mris->vertices[area->lv[i].vno] ;
v->marked++ ;
index = v->marked ;
cx[index] += v->x ;
cy[index] += v->y ;
cz[index] += v->z ;
num[index]++ ;
}
memset(new_index, 0, sizeof(new_index[0])*divide) ;
for (i = 1 ; i <= divide ; i++)
cy[i] /= num[i] ;
// order them from posterior to anterior
for (j = 1 ; j <= divide ; j++)
{
min_a = 1e10 ; min_i = 0 ;
for (i = 1 ; i <= divide ; i++)
{
if (cy[i] < min_a)
{
min_a = cy[i] ;
min_i = i ;
}
}
cy[min_i] = 1e10 ; // make it biggest so it won't be considered again
new_index[j] = min_i ;
}
for (i = 0 ; i < area->n_points ; i++)
{
if (area->lv[i].vno < 0 || area->lv[i].deleted > 0)
continue ;
v = &mris->vertices[area->lv[i].vno] ;
v->marked = new_index[v->marked] ;
}
}
for (i = 1 ; i <= divide ; i++)
{
area_division = LabelFromMarkValue(mris, i) ;
printf("performing distance transform on division %d with %d vertices\n",
i, area_division->n_points) ;
if (output_label)
{
sprintf(fname, "%s%d.label", base_name, i) ;
printf("writing %dth subdivision to %s\n", i, fname) ;
LabelWrite(area_division, fname);
}
MRISdistanceTransform(mris, area_division, mode) ;
sprintf(fname, "%s%d.%s", base_name, i, ext) ;
if (normalize > 0)
MRISmulVal(mris, 1.0/normalize) ;
MRISwriteValues(mris, fname) ;
}
}
else
{
MRISdistanceTransform(mris, area, mode) ;
if (normalize > 0)
MRISmulVal(mris, 1.0/normalize) ;
MRISwriteValues(mris, output_fname) ;
}
}
msec = TimerStop(&then) ;
fprintf(stderr,"distance transform took %2.1f minutes\n", (float)msec/(60*1000.0f));
exit(0) ;
return(0) ; /* for ansi */
}
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[]) {
int nargs,n,err;
MRIS *SurfReg[100];
MRI *SrcVal, *TrgVal;
char *base;
COLOR_TABLE *ctab=NULL;
nargs = handle_version_option (argc, argv, vcid, "$Name: $");
if (nargs && argc - nargs == 1) exit (0);
argc -= nargs;
cmdline = argv2cmdline(argc,argv);
uname(&uts);
getcwd(cwd,2000);
Progname = argv[0] ;
argc --;
argv++;
ErrorInit(NULL, NULL, NULL) ;
DiagInit(NULL, NULL, NULL) ;
if (argc == 0) usage_exit();
parse_commandline(argc, argv);
check_options();
if (checkoptsonly) return(0);
dump_options(stdout);
// Load in surface registrations
for(n=0; n<nsurfs;n++){
printf("%d Loading %s\n",n+1,SurfRegFile[n]);
base = fio_basename(SurfRegFile[n],".tri");
if(strcmp(base,"ic7")==0){
// Have to do it this way to rescale. Need to find a better more robust way.
printf(" reading as ico 7, rescaling radius to 100\n");
SurfReg[n] = ReadIcoByOrder(7, 100);
}
else
SurfReg[n] = MRISread(SurfRegFile[n]);
free(base);
if(SurfReg[n]==NULL) exit(1);
}
// Load in source data
SrcVal = NULL;
if(DoSynthRand) {
if (SynthSeed < 0) SynthSeed = PDFtodSeed();
printf("INFO: synthesizing, seed = %d\n",SynthSeed);
srand48(SynthSeed);
MRIrandn(SrcVal->width, SrcVal->height, SrcVal->depth,
SrcVal->nframes,0, 1, SrcVal);
}
else if(DoSynthOnes != 0) {
printf("INFO: filling input with all 1s\n");
MRIconst(SrcVal->width, SrcVal->height, SrcVal->depth,
SrcVal->nframes, 1, SrcVal);
}
else if(AnnotFile) {
printf("Loading annotation %s\n",AnnotFile);
err = MRISreadAnnotation(SurfReg[0], AnnotFile);
if(err) exit(1);
SrcVal = MRISannotIndex2Seg(SurfReg[0]);
ctab = CTABdeepCopy(SurfReg[0]->ct);
}
else if(LabelFile) {
LABEL *srclabel;
printf("Loading label %s\n",LabelFile);
srclabel = LabelRead(NULL, LabelFile);
if(srclabel == NULL) exit(1);
SrcVal = MRISlabel2Mask(SurfReg[0],srclabel,NULL);
printf(" %d points in input label\n",srclabel->n_points);
LabelFree(&srclabel);
}
else {
printf("Loading %s\n",SrcValFile);
SrcVal = MRIread(SrcValFile);
if(SrcVal==NULL) exit(1);
}
// Apply registration to source
TrgVal = MRISapplyReg(SrcVal, SurfReg, nsurfs, ReverseMapFlag, DoJac, UseHash);
if(TrgVal == NULL) exit(1);
// Save output
if(AnnotFile){
printf("Converting to target annot\n");
err = MRISseg2annot(SurfReg[nsurfs-1],TrgVal,ctab);
if(err) exit(1);
printf("Writing %s\n",TrgValFile);
MRISwriteAnnotation(SurfReg[nsurfs-1], TrgValFile);
}
else if(LabelFile){
LABEL *label;
label = MRISmask2Label(SurfReg[nsurfs-1], TrgVal, 0, 10e-5);
printf(" %d points in output label\n",label->n_points);
err = LabelWrite(label,TrgValFile);
if(err){
printf("ERROR: writing label file %s\n",TrgValFile);
exit(1);
}
LabelFree(&label);
}
else{
printf("Writing %s\n",TrgValFile);
MRIwrite(TrgVal,TrgValFile);
}
printf("mris_apply_reg done\n");
return 0;
}
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);
}
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);
}
/*--------------------------------------------------------------------*/
static int convert_path_to_label (char* fname, char* ofname) {
int err;
int num_paths;
PATH** paths = NULL;
int path_index;
int label_size;
int pno;
LABEL* label = NULL;
int label_vno;
/* Read the paths file. */
err = PathReadMany (fname, &num_paths, &paths);
if (ERROR_NONE != err) {
ErrorReturn (ERROR_BADFILE,
(ERROR_BADFILE, "Couldn't read %s", fname));
}
printf ("INFO: Got %d paths\n\n", num_paths);
/* Go through the paths we can and build a sum of number of points
we'll need to write to the label, including an extra one per path
for the sentinel value. */
label_vno = 0;
label_size = 0;
for (path_index = 0; path_index < num_paths; path_index++) {
label_size += paths[path_index]->n_points + 1;
}
/* Allocate a label of that size. */
label = LabelAlloc (label_size, NULL, NULL);
if (NULL == label) {
ErrorReturn (ERROR_NO_MEMORY,
(ERROR_NO_MEMORY, "Couldn't allocate label of %d points",
label_size));
}
label->n_points = label_size;
/* For each path...*/
for (path_index = 0; path_index < num_paths; path_index++) {
/* Write all the path points to the label. */
for (pno = 0; pno < paths[path_index]->n_points; pno++) {
label->lv[label_vno].x = paths[path_index]->points[pno].x;
label->lv[label_vno].y = paths[path_index]->points[pno].y;
label->lv[label_vno].z = paths[path_index]->points[pno].z;
label->lv[label_vno].vno = paths[path_index]->points[pno].vno;
label_vno++;
}
/* Write the sentinel value. */
label->lv[label_vno].x = -99999;
label->lv[label_vno].y = -99999;
label->lv[label_vno].z = -99999;
label->lv[label_vno].vno = -99999;
label_vno++;
/* Go ahead and delte the path now. */
PathFree (&paths[path_index]);
}
/* Free our paths variable. */
free (paths);
/* Write the label file. */
LabelWrite (label, ofname);
/* Free the label. */
LabelFree (&label);
return (ERROR_NONE);
}
