int
IOPNormalize(IOP *iop)
{
int j,k,jc;
double sum, val;
for (j=0;j<iop->ndipoles;j++)
{
sum = 0;
for (jc=0;jc<iop->ndipoles_per_location;jc++)
for (k=0;k<iop->nchan;k++)
{
val = *MATRIX_RELT(iop->m_iop,j*iop->ndipoles_per_location+jc+1,k+1);
sum += SQR(val);
}
sum = sqrt(sum);
if (!DZERO(sum))
{
for (jc=0;jc<iop->ndipoles_per_location;jc++)
for (k=0;k<iop->nchan;k++)
*MATRIX_RELT(iop->m_iop,j*iop->ndipoles_per_location+jc+1,k+1)/= sum;
}
}
return(NO_ERROR) ;
}
static double
FLASHforwardModel(double flip_angle, double TR, double PD, double T1) {
double FLASH, E1 ;
double CFA, SFA ;
CFA = cos(flip_angle) ;
SFA = sin(flip_angle) ;
E1 = exp(-TR/T1) ;
FLASH = PD * SFA ;
if (!DZERO(T1))
FLASH *= (1-E1)/(1-CFA*E1);
return(FLASH) ;
}
static MRI *
MRIcomputeSurfaceDistanceProbabilities(MRI_SURFACE *mris, MRI *mri_ribbon, MRI *mri, MRI *mri_aseg)
{
MRI *mri_features, *mri_binary, *mri_white_dist, *mri_pial_dist, *mri_mask ;
int nwhite_bins, npial_bins, x, y, z, label, i ;
HISTOGRAM2D *hw, *hp ;
float pdist, wdist, val ;
double wval, pval ;
mri_features = MRIallocSequence(mri->width, mri->height, mri->depth, MRI_FLOAT, 2) ;
MRIcopyHeader(mri, mri_features) ;
mri_binary = MRIcopy(mri_ribbon, NULL) ;
mri_binary = MRIbinarize(mri_ribbon, NULL, 1, 0, 1) ;
mri_pial_dist = MRIdistanceTransform(mri_binary, NULL, 1, max_pial_dist+1, DTRANS_MODE_SIGNED,NULL);
if (Gdiag & DIAG_WRITE && DIAG_VERBOSE_ON)
MRIwrite(mri_pial_dist, "pd.mgz") ;
MRIclear(mri_binary) ;
MRIcopyLabel(mri_ribbon, mri_binary, Left_Cerebral_White_Matter) ;
MRIcopyLabel(mri_ribbon, mri_binary, Right_Cerebral_White_Matter) ;
MRIbinarize(mri_binary, mri_binary, 1, 0, 1) ;
mri_white_dist = MRIdistanceTransform(mri_binary, NULL, 1, max_white_dist+1, DTRANS_MODE_SIGNED,NULL);
if (Gdiag & DIAG_WRITE && DIAG_VERBOSE_ON)
MRIwrite(mri_white_dist, "wd.mgz") ;
nwhite_bins = ceil((max_white_dist - min_white_dist) / white_bin_size)+1 ;
npial_bins = ceil((max_pial_dist - min_pial_dist) / pial_bin_size)+1 ;
hw = HISTO2Dalloc(NBINS, nwhite_bins) ;
hp = HISTO2Dalloc(NBINS, npial_bins) ;
HISTO2Dinit(hw, NBINS, nwhite_bins, 0, NBINS-1, min_white_dist, max_white_dist) ;
HISTO2Dinit(hp, NBINS, npial_bins, 0, NBINS-1, min_pial_dist, max_pial_dist) ;
for (x = 0 ; x < mri->width ; x++)
for (y = 0 ; y < mri->height ; y++)
for (z = 0 ; z < mri->depth ; z++)
{
label = MRIgetVoxVal(mri_aseg, x, y, z, 0) ;
if (IS_CEREBELLUM(label) || IS_VENTRICLE(label) || label == Brain_Stem || IS_CC(label))
continue ;
pdist = MRIgetVoxVal(mri_pial_dist, x, y, z, 0) ;
wdist = MRIgetVoxVal(mri_pial_dist, x, y, z, 0) ;
val = MRIgetVoxVal(mri, x, y, z, 0) ;
if (pdist >= min_pial_dist && pdist <= max_pial_dist)
HISTO2DaddSample(hp, val, pdist, 0, 0, 0, 0) ;
if (wdist >= min_white_dist && wdist <= max_white_dist)
HISTO2DaddSample(hw, val, wdist, 0, 0, 0, 0) ;
}
HISTO2DmakePDF(hp, hp) ;
HISTO2DmakePDF(hw, hw) ;
for (x = 0 ; x < mri->width ; x++)
for (y = 0 ; y < mri->height ; y++)
for (z = 0 ; z < mri->depth ; z++)
{
label = MRIgetVoxVal(mri_aseg, x, y, z, 0) ;
if (IS_CEREBELLUM(label) || IS_VENTRICLE(label) || label == Brain_Stem || IS_CC(label))
continue ;
pdist = MRIgetVoxVal(mri_pial_dist, x, y, z, 0) ;
wdist = MRIgetVoxVal(mri_pial_dist, x, y, z, 0) ;
val = MRIgetVoxVal(mri, x, y, z, 0) ;
wval = HISTO2DgetCount(hw, val, wdist);
if (DZERO(wval) == 0)
MRIsetVoxVal(mri_features, x, y, z, 1, -log10(wval)) ;
pval = HISTO2DgetCount(hp, val, pdist);
if (DZERO(pval) == 0)
MRIsetVoxVal(mri_features, x, y, z, 0, -log10(pval)) ;
}
MRIclear(mri_binary) ;
MRIbinarize(mri_ribbon, mri_binary, 1, 0, 1) ;
mri_mask = MRIcopy(mri_binary, NULL) ;
for (i = 0 ; i < close_order ; i++)
{
MRIdilate(mri_binary, mri_mask) ;
MRIcopy(mri_mask, mri_binary) ;
}
for (i = 0 ; i < close_order ; i++)
{
MRIerode(mri_binary, mri_mask) ;
MRIcopy(mri_mask, mri_binary) ;
}
MRIwrite(mri_mask, "m.mgz") ;
MRImask(mri_features, mri_mask, mri_features, 0, 0) ;
HISTO2Dfree(&hw) ;
HISTO2Dfree(&hp) ;
MRIfree(&mri_white_dist) ; MRIfree(&mri_pial_dist) ; MRIfree(&mri_binary) ;
return(mri_features) ;
}
int
main(int argc, char *argv[]) {
char **av, fname[STRLEN], *subject_name, *wfile_name,
*cp, *hemi ;
int ac, nargs, vno ;
MRI_SURFACE *mris ;
VERTEX *v ;
double entropy, total_len, min_w ;
/* rkt: check for and handle version tag */
nargs = handle_version_option (argc, argv, "$Id: mris_entropy.c,v 1.7 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 < 3)
print_help() ;
subject_name = argv[1] ;
hemi = argv[2] ;
wfile_name = argv[3] ;
if (strlen(sdir) == 0) {
cp = getenv("SUBJECTS_DIR") ;
if (!cp)
ErrorExit(ERROR_UNSUPPORTED, "%s: must specifiy SUBJECTS_DIR in env",
Progname) ;
strcpy(sdir, cp) ;
}
sprintf(fname, "%s/%s/surf/%s.%s", sdir, subject_name, hemi, ORIG_NAME) ;
mris = MRISfastRead(fname) ;
if (!mris)
ErrorExit(ERROR_NOFILE, "%s: could not read surface file %s",
Progname, fname) ;
if (MRISreadValues(mris, wfile_name) != NO_ERROR)
ErrorExit(ERROR_NOFILE, "%s: could not read w file %s",
Progname, wfile_name) ;
if (navgs > 0) {
printf("smoothing surface values for %d iterations...\n",navgs) ;
MRISaverageVals(mris, navgs) ;
}
min_w = fabs(mris->vertices[0].val) ;
for (total_len = vno = 0 ; vno < mris->nvertices ; vno++) {
v = &mris->vertices[vno] ;
if (v->ripflag)
continue ;
v->val = fabs(v->val) ;
total_len += (v->val*v->val) ;
if (v->val < min_w)
min_w = v->val ;
}
total_len = sqrt(total_len) ;
if (FZERO(total_len))
ErrorExit(ERROR_BADPARM, "total vector len = 0, entropy = 0 (trivial case)") ;
for (entropy = vno = 0 ; vno < mris->nvertices ; vno++) {
v = &mris->vertices[vno] ;
if (v->ripflag)
continue ;
if (DZERO(v->val))
continue ;
v->val = v->val / total_len ;
entropy += v->val * log2(v->val) ;
}
entropy = -entropy ;
printf("total entropy = %f\n", entropy) ;
if (log_fname) {
FILE *fp ;
fp = fopen(log_fname, "a") ;
if (!fp)
ErrorExit(ERROR_NOFILE, "%s: could not open log file %s\n", Progname,log_fname) ;
fprintf(fp, "%f\n", entropy) ;
fclose(fp) ;
}
exit(0) ;
return(0) ; /* for ansi */
}
static MRI *
MRIfindInnerBoundary(MRI *mri_src, MRI *mri_grad, MRI *mri_dst, float dist) {
int x, y, z, nsamples ;
double x1, y1, z1, dx, dy, dz, dot, d, inside, outside, norm, val, xc, yc, zc, wt ;
if (mri_dst == NULL)
mri_dst = MRIclone(mri_src, NULL) ;
xc = yc = zc = 0.0 ;
for (wt = 0.0, x = 0 ; x < mri_src->width ; x++) {
for (y = 0 ; y < mri_src->height ; y++) {
for (z = 0 ; z < mri_src->depth ; z++) {
val = MRIgetVoxVal(mri_src, x, y, z, 0) ;
xc += val*x ;
yc += val*y ;
zc += val*z ;
wt += val ;
}
}
}
xc /= wt ;
yc /= wt ;
zc /= wt ;
for (x = 0 ; x < mri_src->width ; x++) {
for (y = 0 ; y < mri_src->height ; y++) {
for (z = 0 ; z < mri_src->depth ; z++) {
if (x == Gx && y == Gy && z == Gz)
DiagBreak() ;
dx = MRIgetVoxVal(mri_grad, x, y, z, 0) ;
dy = MRIgetVoxVal(mri_grad, x, y, z, 1) ;
dz = MRIgetVoxVal(mri_grad, x, y, z, 2) ;
norm = sqrt(dx*dx + dy*dy + dz*dz) ;
if (DZERO(norm))
continue ;
dx /= norm ;
dy /= norm ;
dz /= norm ;
dot = dx * (x-xc) + dy * (y-yc) + dz * (z-zc);
if (dot < 0)
continue ;
for (nsamples = 0, outside = 0, d = .1 ; d < dist ; d += 0.1, nsamples++) {
x1 = x+d*dx ;
y1 = y+d*dy ;
z1 = z+d*dz ;
MRIsampleVolume(mri_src, x1, y1, z1, &val) ;
outside += val ;
}
for (nsamples = 0, inside = 0, d = .1 ; d < dist ; d += 0.1, nsamples++) {
x1 = x-d*dx ;
y1 = y-d*dy ;
z1 = z-d*dz ;
MRIsampleVolume(mri_src, x1, y1, z1, &val) ;
inside += val ;
}
outside /= nsamples ;
inside /= nsamples ;
MRIsetVoxVal(mri_dst, x, y, z, 0, outside-inside) ;
}
}
}
return(mri_dst) ;
}
static MRI *
build_distance_by_intensity_histo(MRI *mri_norm,
MRI *mri_dist,
MRI *mri_aseg,
double dist_spacing,
double max_dist)
{
HISTOGRAM2D *h_dist_by_int ;
int x, y, z, b1, b2, label ;
float val, dist ;
double total, unlikely, pval ;
MRI *mri_pvals ;
h_dist_by_int = HISTO2Dalloc((int)ceil(max_dist/dist_spacing), 256) ;
HISTO2Dinit(h_dist_by_int,
h_dist_by_int->nbins1,
h_dist_by_int->nbins2,
0,
MAX_DIST,
0,
255) ;
for (x = 0 ; x < mri_dist->width ; x++)
for (y = 0 ; y < mri_dist->height ; y++)
for (z = 0 ; z < mri_dist->depth ; z++)
{
if (x == Gx && y == Gy && z == Gz)
{
DiagBreak() ;
}
dist = MRIgetVoxVal(mri_dist, x, y, z, 0) ;
if (dist < 0 || dist > MAX_DIST) // in interior or too far away
{
continue ;
}
label = MRIgetVoxVal(mri_aseg, x, y, z, 0) ;
if (IS_WHITE_CLASS(label) == 0 &&
IS_CORTEX(label) == 0 &&
label < MIN_CORTICAL_PARCELLATION)
{
continue ;
}
val = MRIgetVoxVal(mri_norm, x, y, z, 0) ;
HISTO2DaddSample(h_dist_by_int, dist, val, 0, max_dist, 0, 255) ;
}
// normalize the counts for each distance
for (b1 = 0 ; b1 < h_dist_by_int->nbins1 ; b1++)
{
for (total = 0.0, b2 = 0 ; b2 < h_dist_by_int->nbins2 ; b2++)
{
total += h_dist_by_int->counts[b1][b2] ;
}
if (total > 0)
{
unlikely = 1.0/(10*total) ;
for (b2 = 0 ; b2 < h_dist_by_int->nbins2 ; b2++)
{
h_dist_by_int->counts[b1][b2]/=total ;
if (DZERO(h_dist_by_int->counts[b1][b2]))
{
h_dist_by_int->counts[b1][b2] = unlikely ;
}
}
}
}
mri_pvals = MRIclone(mri_dist, NULL) ;
for (x = 0 ; x < mri_dist->width ; x++)
for (y = 0 ; y < mri_dist->height ; y++)
for (z = 0 ; z < mri_dist->depth ; z++)
{
if (x == Gx && y == Gy && z == Gz)
{
DiagBreak() ;
}
dist = MRIgetVoxVal(mri_dist, x, y, z, 0) ;
if (dist < 0 || dist > MAX_DIST) // in interior
{
continue ;
}
label = MRIgetVoxVal(mri_aseg, x, y, z, 0) ;
if (IS_WHITE_CLASS(label) == 0 &&
IS_CORTEX(label) == 0 &&
label < MIN_CORTICAL_PARCELLATION)
{
continue ;
}
val = MRIgetVoxVal(mri_norm, x, y, z, 0) ;
pval = HISTO2DgetCount(h_dist_by_int, dist, val) ;
if (pval > 0)
{
pval = -log10(pval) ;
}
else
{
pval = -10000 ;
}
MRIsetVoxVal(mri_pvals, x, y, z, 0, pval) ;
}
HISTO2Dfree(&h_dist_by_int) ;
return(mri_pvals) ;
}
