int
main(int argc, char *argv[])
{
char **av, fname[STRLEN], *cp ;
int ac, nargs ;
char *subject, *out_fname, *hemi, *ohemi ;
int msec, minutes, seconds ;
struct timeb start ;
MRI *mri, *mri_features, *mri_ribbon, *mri_aseg, *mri_aparc ;
MRI_SURFACE *mris, *mris_contra ;
LABEL *cortex ;
/* rkt: check for and handle version tag */
nargs = handle_version_option (argc, argv, "$Id: mri_extract_fcd_features.c,v 1.1 2016/06/15 17:51:09 fischl 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 < 4)
usage_exit(1) ;
subject = argv[1] ;
hemi = argv[2] ;
if (strcmp(hemi, "lh") == 0)
ohemi = "rh" ;
else
ohemi = "lh" ;
out_fname = argv[3] ;
printf("reading data for subject %s and writing output to %s\n", subject, out_fname) ;
if (!strlen(sdir))
{
cp = getenv("SUBJECTS_DIR") ;
if (!cp)
ErrorExit(ERROR_BADPARM,
"%s: SUBJECTS_DIR not defined in environment.\n", Progname) ;
strcpy(sdir, cp) ;
}
sprintf(fname, "%s/%s/surf/%s.%s", sdir, subject, hemi, white_name) ;
printf("reading %s\n", fname) ;
mris = MRISread(fname) ;
if (mris == NULL)
ErrorExit(ERROR_NOFILE, "%s: could not read surface from %s\n", Progname, fname) ;
MRISsaveVertexPositions(mris, WHITE_VERTICES) ;
sprintf(fname, "%s/%s/surf/%s.%s", sdir, subject, ohemi, white_name) ;
printf("reading %s\n", fname) ;
mris_contra = MRISread(fname) ;
if (mris_contra == NULL)
ErrorExit(ERROR_NOFILE, "%s: could not read surface from %s\n", Progname, fname) ;
MRISsaveVertexPositions(mris_contra, WHITE_VERTICES) ;
sprintf(fname, "%s/%s/mri/%s", sdir, subject, ribbon_name) ;
printf("reading %s\n", fname) ;
mri_ribbon = MRIread(fname) ;
if (mri_ribbon == NULL)
ErrorExit(ERROR_NOFILE, "%s: could not read ribbon from %s\n", Progname, fname) ;
sprintf(fname, "%s/%s/mri/%s", sdir, subject, aparc_name) ;
printf("reading %s\n", fname) ;
mri_aparc = MRIread(fname) ;
if (mri_aparc == NULL)
ErrorExit(ERROR_NOFILE, "%s: could not read ribbon from %s\n", Progname, fname) ;
sprintf(fname, "%s/%s/mri/%s", sdir, subject, aseg_name) ;
printf("reading %s\n", fname) ;
mri_aseg = MRIread(fname) ;
if (mri_aseg == NULL)
ErrorExit(ERROR_NOFILE, "%s: could not read aseg from %s\n", Progname, fname) ;
sprintf(fname, "%s/%s/surf/%s.%s", sdir, subject, hemi, pial_name) ;
if (MRISreadPialCoordinates(mris, fname) != NO_ERROR)
ErrorExit(ERROR_NOFILE, "%s: could not read pial coordinates from %s\n", Progname, fname) ;
sprintf(fname, "%s/%s/surf/%s.%s", sdir, subject, hemi, sphere_name) ;
if (MRISreadCanonicalCoordinates(mris, fname) != NO_ERROR)
ErrorExit(ERROR_NOFILE, "%s: could not read left/right spherical coordinates from %s\n", Progname, fname) ;
sprintf(fname, "%s/%s/surf/%s.%s", sdir, subject, ohemi, pial_name) ;
if (MRISreadPialCoordinates(mris_contra, fname) != NO_ERROR)
ErrorExit(ERROR_NOFILE, "%s: could not read pial coordinates from %s\n", Progname, fname) ;
sprintf(fname, "%s/%s/label/%s.%s", sdir, subject, hemi, cortex_label) ;
cortex = LabelRead(NULL, fname) ;
if (cortex == NULL)
ErrorExit(ERROR_NOFILE, "%s: could not read cortical label from %s\n", Progname, fname) ;
LabelRipRestOfSurface(cortex, mris) ;
LabelFree(&cortex) ;
sprintf(fname, "%s/%s/surf/%s.%s", sdir, subject, ohemi, sphere_name) ;
if (MRISreadCanonicalCoordinates(mris_contra, fname) != NO_ERROR)
ErrorExit(ERROR_NOFILE, "%s: could not read left/right spherical coordinates from %s\n", Progname, fname) ;
sprintf(fname, "%s/%s/mri/%s", sdir, subject, vol_name) ;
printf("reading %s\n", fname) ;
mri = MRIread(fname) ;
if (mri == NULL)
ErrorExit(ERROR_NOFILE, "%s: could not read volume from %s\n", Progname, fname) ;
if (0)
mri_features = MRIcomputeSurfaceDistanceProbabilities(mris, mri_ribbon, mri, mri_aseg) ;
else
{
MRI *mri_ohemi_features, *mri_ohemi_mapped_to_hemi_features ;
mri_features = MRIcomputeSurfaceDistanceIntensities(mris, mri_ribbon, mri_aparc, mri, mri_aseg, whalf) ;
mri_ohemi_features = MRIcomputeSurfaceDistanceIntensities(mris_contra, mri_ribbon, mri_aparc, mri, mri_aseg, whalf) ;
mri_ohemi_mapped_to_hemi_features = MRISmapToSurface(mris_contra, mris, mri_ohemi_features, NULL) ; // map contra feature to this surface
// MRIwrite(mri_ohemi_mapped_to_hemi_features, "test.mgz") ;
MRIsubtract(mri_features, mri_ohemi_mapped_to_hemi_features, mri_features) ;
}
if (navgs > 0)
{
MRI *mri_tmp ;
mri_tmp = MRISsmoothMRI(mris, mri_features, navgs, NULL, NULL);
MRIfree(&mri_features) ;
mri_features = mri_tmp ;
}
printf("writing output to %s\n", out_fname) ;
if (Gdiag_no >= 0)
printf("feature(%d) = %f\n", Gdiag_no, MRIgetVoxVal(mri_features, Gdiag_no, 0, 0, 0)) ;
MRIwrite(mri_features, out_fname) ;
msec = TimerStop(&start) ;
seconds = nint((float)msec/1000.0f) ;
minutes = seconds / 60 ;
seconds = seconds % 60 ;
fprintf(stderr, "feature extraction took %d minutes and %d seconds.\n", minutes, seconds) ;
exit(0) ;
return(0) ;
}
static int
initialize_surface_position(MRI_SURFACE *mris, MRI *mri_masked, int outside, INTEGRATION_PARMS *parms) {
MRI *mri_dilated ;
int x, y, z, vno ;
double x0, y0, z0, radius = 0, dist, num ;
Real xs, ys, zs ;
VERTEX *v ;
if (outside) {
mri_dilated = MRIdilate(mri_masked, NULL) ;
MRIsubtract(mri_dilated, mri_masked, mri_dilated) ;
MRIwrite(mri_dilated, "outside.mgz") ;
num = x0 = y0 = z0 = 0 ;
for (x = 0 ; x < mri_dilated->width ; x++) {
for (y = 0 ; y < mri_dilated->height ; y++) {
for (z = 0 ; z < mri_dilated->depth ; z++) {
if (MRIgetVoxVal(mri_dilated, x, y, z,0) > 0) {
MRIvoxelToSurfaceRAS(mri_dilated, x, y, z, &xs, &ys, &zs) ;
x0 += xs ;
y0 += ys ;
z0 += zs ;
num++ ;
}
}
}
}
x0 /= num ;
y0 /= num ;
z0 /= num ;
printf("centroid at (%2.1f, %2.1f, %2.1f)\n", x0, y0, z0) ;
num = radius = 0 ;
for (x = 0 ; x < mri_dilated->width ; x++) {
for (y = 0 ; y < mri_dilated->height ; y++) {
for (z = 0 ; z < mri_dilated->depth ; z++) {
if (MRIgetVoxVal(mri_dilated, x, y, z,0) > 0) {
MRIvoxelToSurfaceRAS(mri_dilated, x, y, z, &xs, &ys, &zs) ;
dist = sqrt(SQR(xs-x0)+SQR(ys-y0)+SQR(zs-z0)) ;
radius += dist ;
num++ ;
}
}
}
}
radius /= num ;
printf("average radius = %2.3f\n", radius) ;
MRIfree(&mri_dilated) ;
MRISprojectOntoSphere(mris, mris, radius*1.25) ;
for (vno = 0 ; vno < mris->nvertices ; vno++) {
v = &mris->vertices[vno] ;
v->x += x0 ;
v->y += y0 ;
v->z += z0 ;
}
MRIScomputeMetricProperties(mris) ;
}
parms->target_radius = radius ;
MRISsaveVertexPositions(mris, ORIGINAL_VERTICES) ;
return(NO_ERROR) ;
}
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
FCDcomputeThicknessLabels(FCD_DATA *fcd,
double thickness_thresh,
double sigma,
int size_thresh)
{
MRI *mri_lh, *mri_rh, *mri_lh_diff, *mri_rh_diff ;
int niter, vno, s ;
MRI_SEGMENTATION *mriseg ;
fcdFreeLabels(fcd) ; // free old ones if they exist
niter = SIGMA_TO_SURFACE_SMOOTH_STEPS(sigma) ;
// do LH
mri_lh = MRIclone(fcd->lh_thickness_on_lh, NULL) ;
mri_rh = MRIclone(fcd->lh_thickness_on_lh, NULL) ;
exec_progress_callback(1, 8, 0, 1) ;
MRISwriteFrameToValues(fcd->mris_lh, fcd->lh_thickness_on_lh, 0) ;
MRISaverageVals(fcd->mris_lh, niter) ;
MRISreadFrameFromValues(fcd->mris_lh, mri_lh, 0) ;
exec_progress_callback(2, 8, 0, 1) ;
MRISwriteFrameToValues(fcd->mris_lh, fcd->rh_thickness_on_lh, 0) ;
MRISaverageVals(fcd->mris_lh, niter) ;
MRISreadFrameFromValues(fcd->mris_lh, mri_rh, 0) ;
mri_lh_diff = MRIsubtract(mri_lh, mri_rh, NULL) ; // lh minus rh on lh
MRIfree(&mri_lh);
MRIfree(&mri_rh) ;
// do RH
mri_lh = MRIclone(fcd->lh_thickness_on_rh, NULL) ;
mri_rh = MRIclone(fcd->lh_thickness_on_rh, NULL) ;
exec_progress_callback(3, 8, 0, 1) ;
MRISwriteFrameToValues(fcd->mris_rh, fcd->lh_thickness_on_rh, 0) ;
MRISaverageVals(fcd->mris_rh, niter) ;
MRISreadFrameFromValues(fcd->mris_rh, mri_lh, 0) ;
exec_progress_callback(4, 8, 0, 1) ;
MRISwriteFrameToValues(fcd->mris_rh, fcd->rh_thickness_on_rh, 0) ;
MRISaverageVals(fcd->mris_rh, niter) ;
MRISreadFrameFromValues(fcd->mris_rh, mri_rh, 0) ;
mri_rh_diff = MRIsubtract(mri_rh, mri_lh, NULL) ; // lh minus rh on rh
MRIfree(&mri_lh);
MRIfree(&mri_rh) ;
MRIclear(fcd->mri_thickness_increase) ;
MRIclear(fcd->mri_thickness_decrease) ;
exec_progress_callback(5, 8, 0, 1) ;
// process left hemisphere
#if 1
#ifdef HAVE_OPENMP
#pragma omp parallel for shared(fcd, mri_lh_diff, Gdiag_no, thickness_thresh) schedule(static,1)
#endif
#endif
for (vno = 0 ; vno < fcd->mris_lh->nvertices ; vno++)
{
double d ;
float val, val2, thickness;
int base_label ;
VERTEX *v ;
v = &fcd->mris_lh->vertices[vno] ;
if (v->ripflag)
{
continue ;
}
thickness = MRIgetVoxVal(fcd->lh_thickness_on_lh, vno, 0, 0, 0) ;
if (vno == Gdiag_no)
{
DiagBreak() ;
}
val = MRIgetVoxVal(mri_lh_diff, vno, 0, 0, 0) ;
if (fabs(val) < thickness_thresh)
{
continue ;
}
for (d = 0, base_label = 0 ; d < thickness ; d += 0.25)
{
double xv, yv, zv;
double xs = v->x+d*v->nx ;
double ys = v->y+d*v->ny ;
double zs = v->z+d*v->nz ;
MRISsurfaceRASToVoxel(fcd->mris_lh,
fcd->mri_thickness_increase,
xs, ys, zs,
&xv, &yv, &zv) ;
int xvi = nint(xv) ;
int yvi = nint(yv) ;
int zvi = nint(zv) ;
int label = MRIgetVoxVal(fcd->mri_aparc, xvi, yvi, zvi, 0) ;
if (IS_WM(label) == 0 &&
label >= MIN_CORTICAL_PARCELLATION &&
label != ctx_lh_unknown)
{
if (label != base_label)
{
if (base_label)
{
break ;
}
}
else
{
base_label = label ;
}
if (val >= 0)
{
val2 = MRIgetVoxVal(fcd->mri_thickness_increase, xvi, yvi, zvi, 0) ;
// check another thread already populated this voxel
if (val > val2)
{
MRIsetVoxVal(fcd->mri_thickness_increase, xvi, yvi, zvi, 0, val) ;
}
}
else
{
val2 = MRIgetVoxVal(fcd->mri_thickness_decrease, xvi, yvi, zvi, 0) ;
// check if another thread already populated this voxel
if (val < val2)
{
MRIsetVoxVal(fcd->mri_thickness_decrease, xvi, yvi, zvi, 0, val) ;
}
}
}
}
}
exec_progress_callback(6, 8, 0, 1) ;
// now do right hemisphere
#if 1
#ifdef HAVE_OPENMP
#pragma omp parallel for shared(fcd, mri_rh_diff, Gdiag_no, thickness_thresh) schedule(static,1)
#endif
#endif
for (vno = 0 ; vno < fcd->mris_rh->nvertices ; vno++)
{
double d ;
float val, val2, thickness;
int base_label ;
VERTEX *v ;
v = &fcd->mris_rh->vertices[vno] ;
if (v->ripflag)
{
continue ;
}
if (vno == Gdiag_no)
{
DiagBreak() ;
}
val = MRIgetVoxVal(mri_rh_diff, vno, 0, 0, 0) ;
if (fabs(val) < thickness_thresh)
{
continue ;
}
thickness = MRIgetVoxVal(fcd->rh_thickness_on_rh, vno, 0, 0, 0) ;
for (d = 0, base_label = 0; d < thickness ; d += 0.25)
{
double xv, yv, zv;
double xs = v->x+d*v->nx ;
double ys = v->y+d*v->ny ;
double zs = v->z+d*v->nz ;
MRISsurfaceRASToVoxel(fcd->mris_rh,
fcd->mri_thickness_increase,
xs, ys, zs,
&xv, &yv, &zv) ;
int xvi = nint(xv) ;
int yvi = nint(yv) ;
int zvi = nint(zv) ;
int label = MRIgetVoxVal(fcd->mri_aparc, xvi, yvi, zvi, 0) ;
if (IS_WM(label) == 0 &&
label >= MIN_CORTICAL_PARCELLATION &&
label != ctx_rh_unknown)
{
if (label != base_label)
{
if (base_label)
{
break ;
}
}
else
{
base_label = label ;
}
if (val >= 0)
{
val2 = MRIgetVoxVal(fcd->mri_thickness_increase, xvi, yvi, zvi, 0) ;
if (val > val2)
{
MRIsetVoxVal(fcd->mri_thickness_increase, xvi, yvi, zvi, 0, val) ;
}
}
else
{
val2 = MRIgetVoxVal(fcd->mri_thickness_decrease, xvi, yvi, zvi, 0) ;
if (val < val2)
{
MRIsetVoxVal(fcd->mri_thickness_decrease, xvi, yvi, zvi, 0, val) ;
}
}
}
}
}
exec_progress_callback(7, 8, 0, 1) ;
mriseg = MRIsegment(fcd->mri_thickness_increase, thickness_thresh, 1e10) ;
MRIeraseSmallSegments(mriseg, fcd->mri_thickness_increase, thickness_thresh) ;
MRIsegmentFree(&mriseg) ;
MRIclose(fcd->mri_thickness_increase, fcd->mri_thickness_increase) ;
mriseg = MRIsegment(fcd->mri_thickness_increase, thickness_thresh, 1e10) ;
MRIremoveSmallSegments(mriseg, size_thresh) ;
printf("segmenting volume at threshold %2.1f with %d "
"smoothing iters yields %d segments\n",
thickness_thresh, niter,mriseg->nsegments) ;
fflush(stdout) ;
exec_progress_callback(8, 8, 0, 1) ;
fcd->nlabels = mriseg->nsegments ;
for (s = 0 ; s < mriseg->nsegments ; s++)
{
int label ;
fcd->labels[s] = MRIsegmentToLabel(mriseg, fcd->mri_thickness_increase, s) ;
label = most_frequent_label(fcd->mri_aparc, &mriseg->segments[s]) ;
strcpy(fcd->labels[s]->name, cma_label_to_name(label)) ;
}
sort_labels(fcd) ;
MRIadd(fcd->mri_thickness_increase, fcd->mri_thickness_decrease, fcd->mri_thickness_difference);
for (s = 0 ; s < mriseg->nsegments ; s++)
{
printf("%s: %2.3fmm\n", fcd->label_names[s], fcd->labels[s]->avg_stat) ;
fflush(stdout) ;
}
MRIfree(&mri_lh_diff) ;
MRIfree(&mri_rh_diff) ;
MRIsegmentFree(&mriseg) ;
return(fcd->nlabels) ;
}
