static double
compute_surface_sse(MRI_SURFACE *mris, MRI *mri, float sample_dist) {
int vno, nsamples ;
VERTEX *v ;
float sse, dist ;
Real val, xw, yw, zw, x, y, z, nx, ny, nz, error ;
for (nsamples = 0, sse = 0.0, vno = 0 ; vno < mris->nvertices ; vno++) {
v = &mris->vertices[vno] ;
if (v->ripflag)
continue ;
if (!finite(v->x) || !finite(v->y) || !finite(v->z))
DiagBreak() ;
// sample outside - want bright stuff out here
nx = v->nx ;
ny = v->ny ;
nz = v->nz ;
for (error = 0.0, dist = 0 ; dist <= sample_dist ; dist += DELTA) {
x = v->x + dist*nx ;
y = v->y + dist*ny ;
z = v->z + dist*nz ;
MRISvertexToVoxel(mris, v, mri, &xw, &yw, &zw);
MRIsampleVolume(mri, xw, yw, zw, &val) ;
val = 1000-val ;
error += (val*val) ;
nsamples++ ;
}
// sample inwards - want dark stuff
for (dist = DELTA ; dist <= sample_dist ; dist += DELTA) {
x = v->x - dist*nx ;
y = v->y - dist*ny ;
z = v->z - dist*nz ;
MRISvertexToVoxel(mris, v, mri, &xw, &yw, &zw);
MRIsampleVolume(mri, xw, yw, zw, &val) ;
val = 0-val ;
error += 100*(val*val) ;
nsamples++ ;
}
sse += error / (float)nsamples ;
}
return(sse) ;
}
static int
compute_rigid_gradient(MRI_SURFACE *mris, MRI *mri, double *pdx, double *pdy, double *pdz) {
int vno ;
VERTEX *v ;
Real val, xw, yw, zw, dx, dy, dz, delV, x, y, z, Ix, Iy, Iz, xv, yv, zv ;
dx = dy = dz = 0.0 ;
for (vno = 0 ; vno < mris->nvertices ; vno++) {
v = &mris->vertices[vno] ;
if (v->ripflag)
continue ;
if (vno == Gdiag_no)
DiagBreak() ;
x = v->x ;
y = v->y ;
z = v->z ;
MRISvertexToVoxel(mris, v, mri, &xw, &yw, &zw);
MRIsampleVolume(mri, xw, yw, zw, &val) ;
MRIsampleVolumeGradient(mri, xw, yw, zw, &Ix, &Iy, &Iz) ;
// convert back to surface coords
xw += Ix ;
yw += Iy ;
zw += Iz ;
if (mris->useRealRAS)
MRIvoxelToWorld(mri, xw, yw, zw, &xv, &yv, &zv) ;
else
MRIvoxelToSurfaceRAS(mri, xw, yw, zw, &xv, &yv, &zv) ;
Ix = xv-v->x ;
Iy = yv-v->y;
Iz = zv-v->z ;
delV = v->val - val ;
dx += delV * Ix ;
dy += delV * Iy ;
dz += delV * Iz ;
if (!finitep((float)dx))
DiagBreak() ;
if (!finitep((float)dy))
DiagBreak() ;
if (!finitep((float)dz))
DiagBreak() ;
}
dx /= mris->nvertices ;
dy /= mris->nvertices ;
dz /= mris->nvertices ;
*pdx = dx ;
*pdy = dy ;
*pdz = dz ;
return(NO_ERROR) ;
}
static double
compute_surface_dist_sse(MRI_SURFACE *mris, MRI *mri) {
double sse = 0.0 ;
int vno ;
VERTEX *v ;
Real val, error, xw, yw, zw ;
for (vno = 0, sse = 0.0 ; vno < mris->nvertices ; vno++) {
v = &mris->vertices[vno] ;
if (v->ripflag)
continue ;
if (vno == Gdiag_no)
DiagBreak() ;
MRISvertexToVoxel(mris, v, mri, &xw, &yw, &zw);
MRIsampleVolume(mri, xw, yw, zw, &val) ;
error = v->val - val ;
sse += error*error ;
}
return(sse) ;
}
static int
augment_thicknesses(FCD_DATA *fcd,
MRI *mri_pvals,
double min_dist,
double max_dist,
double thresh)
{
int h, vno ;
VERTEX *v ;
MRI_SURFACE *mris ;
MRI *mri_thickness ;
double nx, ny, nz, x0, y0, z0, d, x, y, z, val ;
MRI_SEGMENTATION *mriseg ;
mriseg = MRIsegment(mri_pvals, thresh, 1e10) ;
MRIeraseSmallSegments(mriseg, mri_pvals, 20) ;
MRIremoveSmallSegments(mriseg, 100) ;
if (Gdiag & DIAG_WRITE)
{
MRIwrite(mri_pvals, "pvals.mgz") ;
}
MRIsegmentFree(&mriseg) ;
for (h = 0 ; h <= 1 ; h++) // do each hemi
{
if (h == 0) // left hemi
{
mri_thickness = fcd->lh_thickness_on_lh ;
mris = fcd->mris_lh ;
}
else // right hemi
{
mri_thickness = fcd->rh_thickness_on_rh ;
mris = fcd->mris_rh ;
}
for (vno = 0 ; vno < mris->nvertices ; vno++)
{
if (vno == Gdiag_no)
{
DiagBreak() ;
}
v = &mris->vertices[vno] ;
if (v->ripflag)
{
continue ;
}
MRISvertexNormalInVoxelCoords(mris, mri_pvals, vno, &nx, &ny, &nz) ;
MRISvertexToVoxel(mris, v, mri_pvals, &x0, &y0, &z0) ;
for (d = 0 ; d <= max_dist ; d += 0.5)
{
x = x0+d*nx ;
y = y0+d*ny ;
z = z0+d*nz ;
MRIsampleVolume(mri_pvals, x, y, z, &val) ;
if (val < thresh)
{
break ;
}
}
if (d > min_dist) // a string of unlikely values
{
val = MRIgetVoxVal(mri_thickness, vno, 0, 0, 0) ;
MRIsetVoxVal(mri_thickness, vno, 0, 0, 0, val+d) ;
}
}
}
return(NO_ERROR) ;
}
