// map mri data to image data, assuming same data type
void VolumeFilter::MapMRIToVolume( MRI* mri, LayerMRI* layer )
{
vtkImageData* image = layer->GetImageData();
int zX = mri->width;
int zY = mri->height;
int zZ = mri->depth;
int zFrames = mri->nframes;
for ( int nZ = 0; nZ < zZ; nZ++ )
{
for ( int nY = 0; nY < zY; nY++ )
{
for ( int nX = 0; nX < zX; nX++ )
{
for ( int nFrame = 0; nFrame < zFrames; nFrame++ )
{
switch ( mri->type )
{
case MRI_UCHAR:
image->SetScalarComponentFromDouble(nX, nY, nZ, nFrame,
MRIseq_vox( mri, nX, nY, nZ, nFrame ) );
break;
case MRI_INT:
image->SetScalarComponentFromDouble(nX, nY, nZ, nFrame,
MRIIseq_vox( mri, nX, nY, nZ, nFrame ) );
break;
case MRI_LONG:
image->SetScalarComponentFromDouble(nX, nY, nZ, nFrame,
MRILseq_vox( mri, nX, nY, nZ, nFrame ) );
break;
case MRI_FLOAT:
image->SetScalarComponentFromDouble(nX, nY, nZ, nFrame,
MRIFseq_vox( mri, nX, nY, nZ, nFrame ) );
break;
case MRI_SHORT:
image->SetScalarComponentFromDouble(nX, nY, nZ, nFrame,
MRISseq_vox( mri, nX, nY, nZ, nFrame ) );
break;
default:
break;
}
}
}
}
exec_progress_callback(nZ, zZ, 0, 1);
}
}
FCD_DATA *
FCDloadData(char *sdir, char *subject)
{
FCD_DATA *fcd ;
char fname[STRLEN] ;
MRI *mri_interior, *mri_dist, *mri_int_lh, *mri_int_rh, *mri_pvals ;
fcd = (FCD_DATA *)calloc(1, sizeof(FCD_DATA)) ;
sprintf(fname, "%s/%s/surf/lh.white", sdir, subject) ;
fcd->mris_lh = MRISread(fname) ;
if (fcd->mris_lh == NULL)
{
ErrorExit(ERROR_NOFILE, "FCDloadData: couldn't load %s", fname) ;
}
MRISsaveVertexPositions(fcd->mris_lh, WHITE_VERTICES) ;
if (MRISreadPialCoordinates(fcd->mris_lh, "pial") != NO_ERROR)
{
ErrorExit(ERROR_NOFILE, "FCDloadData: couldn't load lh pial vertices") ;
}
sprintf(fname, "%s/%s/surf/lh.pial", sdir, subject) ;
fcd->mris_lh_pial = MRISread(fname) ;
if (fcd->mris_lh_pial == NULL)
{
ErrorExit(ERROR_NOFILE, "FCDloadData: couldn't load %s", fname) ;
}
sprintf(fname, "%s/%s/surf/lh.sphere.d1.left_right", sdir, subject) ;
fcd->mris_lh_sphere_d1 = MRISread(fname) ;
if (fcd->mris_lh_sphere_d1 == NULL)
{
ErrorExit(ERROR_NOFILE, "FCDloadData: couldn't load %s", fname) ;
}
exec_progress_callback(1, 12, 0, 1) ;
sprintf(fname, "%s/%s/surf/rh.white", sdir, subject) ;
fcd->mris_rh = MRISread(fname) ;
if (fcd->mris_rh == NULL)
{
ErrorExit(ERROR_NOFILE, "FCDloadData: couldn't load %s", fname) ;
}
MRISsaveVertexPositions(fcd->mris_rh, WHITE_VERTICES) ;
if (MRISreadPialCoordinates(fcd->mris_rh, "pial") != NO_ERROR)
{
ErrorExit(ERROR_NOFILE, "FCDloadData: couldn't load rh pial vertices") ;
}
sprintf(fname, "%s/%s/surf/rh.pial", sdir, subject) ;
fcd->mris_rh_pial = MRISread(fname) ;
if (fcd->mris_rh_pial == NULL)
{
ErrorExit(ERROR_NOFILE, "FCDloadData: couldn't load %s", fname) ;
}
sprintf(fname, "%s/%s/surf/rh.sphere.d1.left_right", sdir, subject) ;
fcd->mris_rh_sphere_d1 = MRISread(fname) ;
if (fcd->mris_rh_sphere_d1 == NULL)
{
ErrorExit(ERROR_NOFILE, "FCDloadData: couldn't load %s", fname) ;
}
exec_progress_callback(2, 12, 0, 1) ;
sprintf(fname, "%s/%s/mri/aseg.mgz", sdir, subject) ;
fcd->mri_aseg = MRIread(fname) ;
if (fcd->mri_aseg == NULL)
{
ErrorExit(ERROR_NOFILE, "FCDloadData: couldn't load %s", fname) ;
}
exec_progress_callback(3, 12, 0, 1) ;
sprintf(fname, "%s/%s/mri/aparc+aseg.mgz", sdir, subject) ;
fcd->mri_aparc = MRIread(fname) ;
if (fcd->mri_aparc == NULL)
{
ErrorExit(ERROR_NOFILE, "FCDloadData: couldn't load %s", fname) ;
}
exec_progress_callback(4, 12, 0, 1) ;
fcd->mri_flair = NULL;
sprintf(fname, "%s/%s/mri/flair.reg.norm.mgz", sdir, subject) ;
if ( ! FileExists(fname))
{
sprintf(fname, "%s/%s/mri/FLAIR.mgz", sdir, subject) ;
if ( ! FileExists(fname))
{
sprintf(fname, "%s/%s/mri/FLAIRax.mgz", sdir, subject) ;
if ( ! FileExists(fname))
{
sprintf(fname, "%s/%s/mri/FLAIRcor.mgz", sdir, subject) ;
if ( ! FileExists(fname))
{
sprintf(fname, " ");
}
}
}
}
if (strlen(fname) > 1)
{
fcd->mri_flair = MRIread(fname) ;
if (fcd->mri_flair == NULL)
{
ErrorExit(ERROR_NOFILE, "FCDloadData: couldn't load $s", fname) ;
}
}
fcd->mri_t2 = NULL;
sprintf(fname, "%s/%s/mri/T2.mgz", sdir, subject) ;
if ( ! FileExists(fname))
{
sprintf(fname, "%s/%s/mri/T2ax.mgz", sdir, subject) ;
if ( ! FileExists(fname))
{
sprintf(fname, "%s/%s/mri/T2cor.mgz", sdir, subject) ;
if ( ! FileExists(fname))
{
sprintf(fname, " ");
}
}
}
if (strlen(fname) > 1)
{
fcd->mri_t2 = MRIread(fname) ;
if (fcd->mri_t2 == NULL)
{
ErrorExit(ERROR_NOFILE, "FCDloadData: couldn't load $s", fname) ;
}
}
exec_progress_callback(5, 12, 0, 1) ;
sprintf(fname, "%s/%s/mri/norm.mgz", sdir, subject) ;
fcd->mri_norm = MRIread(fname) ;
if (fcd->mri_norm == NULL)
{
ErrorExit(ERROR_NOFILE, "FCDloadData: couldn't load %s", fname) ;
}
fcd->mri_thickness_increase =
MRIcloneDifferentType(fcd->mri_aseg, MRI_FLOAT) ;
fcd->mri_thickness_decrease =
MRIcloneDifferentType(fcd->mri_aseg, MRI_FLOAT) ;
fcd->mri_thickness_difference = MRIadd(fcd->mri_thickness_increase, fcd->mri_thickness_decrease, NULL);
exec_progress_callback(6, 12, 0, 1) ;
sprintf(fname, "%s/%s/surf/lh.rh.thickness.smooth0.mgz", sdir, subject) ;
fcd->rh_thickness_on_lh = MRIread(fname) ;
if (fcd->mri_aseg == NULL)
{
ErrorExit(ERROR_NOFILE, "FCDloadData: couldn't load %s", fname) ;
}
exec_progress_callback(7, 12, 0, 1) ;
sprintf(fname, "%s/%s/surf/rh.thickness.mgz", sdir, subject) ;
fcd->rh_thickness_on_rh = MRIread(fname) ;
if (fcd->rh_thickness_on_rh == NULL)
{
ErrorExit(ERROR_NOFILE, "FCDloadData: couldn't load %s", fname) ;
}
exec_progress_callback(8, 12, 0, 1) ;
sprintf(fname, "%s/%s/surf/lh.thickness.mgz", sdir, subject) ;
fcd->lh_thickness_on_lh = MRIread(fname) ;
if (fcd->lh_thickness_on_lh == NULL)
{
ErrorExit(ERROR_NOFILE, "FCDloadData: couldn't load %s", fname) ;
}
exec_progress_callback(9, 12, 0, 1) ;
sprintf(fname, "%s/%s/surf/rh.lh.thickness.smooth0.mgz", sdir, subject) ;
if ( ! FileExists(fname))
{
sprintf(fname, "%s/%s/surf/rh.lh.thickness.mgz", sdir, subject) ;
if (fcd->lh_thickness_on_rh == NULL)
{
ErrorExit(ERROR_NOFILE, "FCDloadData: couldn't load %s", fname) ;
}
}
fcd->lh_thickness_on_rh = MRIread(fname) ;
exec_progress_callback(10, 12, 0, 1) ;
mri_int_lh = MRIclone(fcd->mri_norm, NULL) ;
mri_int_rh = MRIclone(fcd->mri_norm, NULL) ;
mri_interior = MRIclone(fcd->mri_norm, NULL) ;
mri_dist = MRIcloneDifferentType(mri_interior, MRI_FLOAT) ;
MRISrestoreVertexPositions(fcd->mris_lh, PIAL_VERTICES) ;
MRISrestoreVertexPositions(fcd->mris_rh, PIAL_VERTICES) ;
MRISfillInterior(fcd->mris_lh, mri_interior->xsize, mri_int_lh) ;
MRISfillInterior(fcd->mris_rh, mri_interior->xsize, mri_int_rh) ;
exec_progress_callback(11, 12, 0, 1) ;
MRIor(mri_int_lh, mri_int_rh, mri_interior, 0) ;
MRIfree(&mri_int_lh) ;
MRIfree(&mri_int_rh) ;
MRIbinarize(mri_interior, mri_interior, 1, 0, 1) ;
if (Gdiag & DIAG_WRITE)
{
MRIwrite(mri_interior, "int.mgz") ;
}
MRIdistanceTransform(mri_interior,
mri_dist,
1,
2*MAX_DIST,
DTRANS_MODE_SIGNED,
NULL);
if (Gdiag & DIAG_WRITE)
{
MRIwrite(mri_dist, "dist.mgz") ;
}
mri_pvals = build_distance_by_intensity_histo(fcd->mri_norm,
mri_dist,
fcd->mri_aseg,
DIST_SPACING,
MAX_DIST) ;
exec_progress_callback(12, 12, 0, 1) ;
augment_thicknesses(fcd, mri_pvals, 1.5, 5, 1) ;
MRISrestoreVertexPositions(fcd->mris_lh, WHITE_VERTICES) ;
MRISrestoreVertexPositions(fcd->mris_rh, WHITE_VERTICES) ;
MRIfree(&mri_dist) ;
MRIfree(&mri_interior) ;
MRIfree(&mri_pvals) ;
return(fcd) ;
}
MRI* VolumeFilter::CreateMRIFromVolume( LayerMRI* layer )
{
vtkImageData* image = layer->GetImageData();
int mri_type = MRI_FLOAT;
switch ( image->GetScalarType() )
{
case VTK_CHAR:
case VTK_SIGNED_CHAR:
case VTK_UNSIGNED_CHAR:
mri_type = MRI_UCHAR;
break;
case VTK_INT:
case VTK_UNSIGNED_INT:
mri_type = MRI_INT;
break;
case VTK_LONG:
case VTK_UNSIGNED_LONG:
mri_type = MRI_LONG;
break;
case VTK_SHORT:
case VTK_UNSIGNED_SHORT:
mri_type = MRI_SHORT;
break;
default:
break;
}
int* dim = image->GetDimensions();
int zFrames = image->GetNumberOfScalarComponents();
MRI* mri = MRIallocSequence( dim[0], dim[1], dim[2], mri_type, zFrames );
if ( !mri )
{
cerr << "Can not allocate memory for MRI.\n";
return NULL;
}
for ( int j = 0; j < mri->height; j++ )
{
for ( int k = 0; k < mri->depth; k++ )
{
for ( int i = 0; i < mri->width; i++ )
{
for ( int nFrame = 0; nFrame < mri->nframes; nFrame++ )
{
switch ( mri->type )
{
case MRI_UCHAR:
MRIseq_vox( mri, i, j, k, nFrame ) =
(unsigned char)image->GetScalarComponentAsDouble(i, j, k, nFrame);
break;
case MRI_INT:
MRIIseq_vox( mri, i, j, k, nFrame ) =
(int)image->GetScalarComponentAsDouble(i, j, k, nFrame);
break;
case MRI_LONG:
MRILseq_vox( mri, i, j, k, nFrame ) =
(int)image->GetScalarComponentAsDouble(i, j, k, nFrame);
break;
case MRI_FLOAT:
MRIFseq_vox( mri, i, j, k, nFrame ) =
(int)image->GetScalarComponentAsDouble(i, j, k, nFrame);
break;
case MRI_SHORT:
MRISseq_vox( mri, i, j, k, nFrame ) =
(int)image->GetScalarComponentAsDouble(i, j, k, nFrame);
break;
default:
break;
}
}
}
}
exec_progress_callback(j, mri->height, 0, 1);
}
return mri;
}
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) ;
}
