def group_analysis_signs(design, contrast, mask, signs=None):
"""
This function refits the EM model with a vector of signs.
Used in the permutation tests.
Returns the maximum of the T-statistic within mask
Parameters
----------
design: one of 'block', 'event'
contrast: str
mask: array-like
signs: ndarray, optional
Defaults to np.ones. Should have shape (*,nsubj)
where nsubj is the number of effects combined in the group analysis.
Returns
-------
minT: np.ndarray, minima of T statistic within mask, one for each
vector of signs
maxT: np.ndarray, maxima of T statistic within mask, one for each
vector of signs
"""
maska = np.asarray(mask).astype(np.bool)
# Which subjects have this (contrast, design) pair?
subjects = futil.subject_dirs(design, contrast)
sd = np.array([np.array(load_image(pjoin(s, "sd.nii")))[:,maska]
for s in subjects])
Y = np.array([np.array(load_image(pjoin(s, "effect.nii")))[:,maska]
for s in subjects])
if signs is None:
signs = np.ones((1, Y.shape[0]))
maxT = np.empty(signs.shape[0])
minT = np.empty(signs.shape[0])
for i, sign in enumerate(signs):
signY = sign[:,np.newaxis] * Y
varest = onesample.estimate_varatio(signY, sd)
random_var = varest['random']
adjusted_var = sd**2 + random_var
adjusted_sd = np.sqrt(adjusted_var)
results = onesample.estimate_mean(Y, adjusted_sd)
T = results['t']
minT[i], maxT[i] = np.nanmin(T), np.nanmax(T)
return minT, maxT
def group_analysis(design, contrast):
""" Compute group analysis effect, t, sd for `design` and `contrast`
Saves to disk in 'group' analysis directory
Parameters
----------
design : {'block', 'event'}
contrast : str
contrast name
"""
array = np.array # shorthand
# Directory where output will be written
odir = futil.ensure_dir(futil.DATADIR, 'group', design, contrast)
# Which subjects have this (contrast, design) pair?
subj_con_dirs = futil.subj_des_con_dirs(design, contrast)
if len(subj_con_dirs) == 0:
raise ValueError('No subjects for %s, %s' % (design, contrast))
# Assemble effects and sds into 4D arrays
sds = []
Ys = []
for s in subj_con_dirs:
sd_img = load_image(pjoin(s, "sd.nii"))
effect_img = load_image(pjoin(s, "effect.nii"))
sds.append(sd_img.get_data())
Ys.append(effect_img.get_data())
sd = array(sds)
Y = array(Ys)
# This function estimates the ratio of the fixed effects variance
# (sum(1/sd**2, 0)) to the estimated random effects variance
# (sum(1/(sd+rvar)**2, 0)) where rvar is the random effects variance.
# The EM algorithm used is described in:
#
# Worsley, K.J., Liao, C., Aston, J., Petre, V., Duncan, G.H.,
# Morales, F., Evans, A.C. (2002). \'A general statistical
# analysis for fMRI data\'. NeuroImage, 15:1-15
varest = onesample.estimate_varatio(Y, sd)
random_var = varest['random']
# XXX - if we have a smoother, use
# random_var = varest['fixed'] * smooth(varest['ratio'])
# Having estimated the random effects variance (and possibly smoothed it),
# the corresponding estimate of the effect and its variance is computed and
# saved.
# This is the coordmap we will use
coordmap = futil.load_image_ds105("fiac_00", "wanatomical.nii").coordmap
adjusted_var = sd**2 + random_var
adjusted_sd = np.sqrt(adjusted_var)
results = onesample.estimate_mean(Y, adjusted_sd)
for n in ['effect', 'sd', 't']:
im = api.Image(results[n], copy(coordmap))
save_image(im, pjoin(odir, "%s.nii" % n))
def group_analysis(design, contrast):
""" Compute group analysis effect, t, sd for `design` and `contrast`
Saves to disk in 'group' analysis directory
Parameters
----------
design : {'block', 'event'}
contrast : str
contrast name
"""
array = np.array # shorthand
# Directory where output will be written
odir = futil.ensure_dir(futil.DATADIR, 'group', design, contrast)
# Which subjects have this (contrast, design) pair?
subj_con_dirs = futil.subj_des_con_dirs(design, contrast)
if len(subj_con_dirs) == 0:
raise ValueError('No subjects for %s, %s' % (design, contrast))
# Assemble effects and sds into 4D arrays
sds = []
Ys = []
for s in subj_con_dirs:
sd_img = load_image(pjoin(s, "sd.nii"))
effect_img = load_image(pjoin(s, "effect.nii"))
sds.append(sd_img.get_data())
Ys.append(effect_img.get_data())
sd = array(sds)
Y = array(Ys)
# This function estimates the ratio of the fixed effects variance
# (sum(1/sd**2, 0)) to the estimated random effects variance
# (sum(1/(sd+rvar)**2, 0)) where rvar is the random effects variance.
# The EM algorithm used is described in:
#
# Worsley, K.J., Liao, C., Aston, J., Petre, V., Duncan, G.H.,
# Morales, F., Evans, A.C. (2002). \'A general statistical
# analysis for fMRI data\'. NeuroImage, 15:1-15
varest = onesample.estimate_varatio(Y, sd)
random_var = varest['random']
# XXX - if we have a smoother, use
# random_var = varest['fixed'] * smooth(varest['ratio'])
# Having estimated the random effects variance (and possibly smoothed it),
# the corresponding estimate of the effect and its variance is computed and
# saved.
# This is the coordmap we will use
coordmap = futil.load_image_fiac("fiac_00","wanatomical.nii").coordmap
adjusted_var = sd**2 + random_var
adjusted_sd = np.sqrt(adjusted_var)
results = onesample.estimate_mean(Y, adjusted_sd)
for n in ['effect', 'sd', 't']:
im = api.Image(results[n], copy(coordmap))
save_image(im, pjoin(odir, "%s.nii" % n))
def testrun(self):
funcim = load_image(funcfile)
fmriims = FmriImageList.from_image(funcim, volume_start_times=2.)
f1 = ExperimentalQuantitative("f1", lambda t:t)
f2 = ExperimentalQuantitative("f1", lambda t:t**2)
f3 = ExperimentalQuantitative("f1", lambda t:t**3)
f = f1 + f2 + f3
c = Contrast(f1, f)
c.compute_matrix(fmriims.volume_start_times)
c2 = Contrast(f1 + f2, f)
c2.compute_matrix(fmriims.volume_start_times)
outputs = []
outputs.append(model.output_AR1(self.ar1, fmriims, clobber=True))
outputs.append(model.output_resid(self.resid_OLS, fmriims,
clobber=True))
ols = model.OLS(fmriims, f, outputs)
ols.execute()
outputs = []
out_fn = os.path.join(self.out_dir, 'out.nii')
outputs.append(model.output_T(out_fn, c, fmriims, clobber=True))
outputs.append(model.output_F(self.F, c2, fmriims, clobber=True))
outputs.append(model.output_resid(self.resid, fmriims, clobber=True))
rho = load_image(self.ar1)
ar = model.AR1(fmriims, f, rho, outputs)
ar.execute()
def test_save1():
# A test to ensure that when a file is saved, the affine and the
# data agree. This image comes from a NIFTI file
img = load_image(funcfile)
save_image(img, tmpfile.name)
img2 = load_image(tmpfile.name)
yield assert_true, np.allclose(img.affine, img2.affine)
yield assert_equal, img.shape, img2.shape
yield assert_true, np.allclose(np.asarray(img2), np.asarray(img))
def test_save1():
# A test to ensure that when a file is saved, the affine and the
# data agree. This image comes from a NIFTI file
img = load_image(funcfile)
with InTemporaryDirectory():
save_image(img, TMP_FNAME)
img2 = load_image(TMP_FNAME)
assert_array_almost_equal(img.affine, img2.affine)
assert_equal(img.shape, img2.shape)
assert_array_almost_equal(img2.get_data(), img.get_data())
del img2
def test_save1():
# A test to ensure that when a file is saved, the affine and the
# data agree. This image comes from a NIFTI file
img = load_image(funcfile)
with InTemporaryDirectory():
save_image(img, TMP_FNAME)
img2 = load_image(TMP_FNAME)
assert_array_almost_equal(img.affine, img2.affine)
assert_equal(img.shape, img2.shape)
assert_array_almost_equal(img2.get_data(), img.get_data())
del img2
def fixed_effects(subj, design):
""" Fixed effects (within subject) for OpenfMRI ds105 model
Finds run by run estimated model results, creates fixed effects results
image per subject.
Parameters
----------
subj : int
subject number 1..6 inclusive
design : {'standard'}
design type
"""
# First, find all the effect and standard deviation images
# for the subject and this design type
path_dict = futil.path_info_design(subj, design)
rootdir = path_dict['rootdir']
# The output directory
fixdir = pjoin(rootdir, "fixed")
# Fetch results images from run estimations
results = futil.results_table(path_dict)
# Get our hands on the relevant coordmap to save our results
coordmap = futil.load_image_ds105("_%02d" % subj,
"wanatomical.nii").coordmap
# Compute the "fixed" effects for each type of contrast
for con in results:
fixed_effect = 0
fixed_var = 0
for effect, sd in results[con]:
effect = load_image(effect).get_data()
sd = load_image(sd).get_data()
var = sd**2
# The optimal, in terms of minimum variance, combination of the
# effects has weights 1 / var
#
# XXX regions with 0 variance are set to 0
# XXX do we want this or np.nan?
ivar = np.nan_to_num(1. / var)
fixed_effect += effect * ivar
fixed_var += ivar
# Now, compute the fixed effects variance and t statistic
fixed_sd = np.sqrt(fixed_var)
isd = np.nan_to_num(1. / fixed_sd)
fixed_t = fixed_effect * isd
# Save the results
odir = futil.ensure_dir(fixdir, con)
for a, n in zip([fixed_effect, fixed_sd, fixed_t],
['effect', 'sd', 't']):
im = api.Image(a, copy(coordmap))
save_image(im, pjoin(odir, '%s.nii' % n))
def fixed_effects(subj, design):
""" Fixed effects (within subject) for FIAC model
Finds run by run estimated model results, creates fixed effects results
image per subject.
Parameters
----------
subj : int
subject number 1..6 inclusive
design : {'standard'}
design type
"""
# First, find all the effect and standard deviation images
# for the subject and this design type
path_dict = futil.path_info_design(subj, design)
rootdir = path_dict['rootdir']
# The output directory
fixdir = pjoin(rootdir, "fixed")
# Fetch results images from run estimations
results = futil.results_table(path_dict)
# Get our hands on the relevant coordmap to save our results
coordmap = futil.load_image_fiac("_%02d" % subj,
"wanatomical.nii").coordmap
# Compute the "fixed" effects for each type of contrast
for con in results:
fixed_effect = 0
fixed_var = 0
for effect, sd in results[con]:
effect = load_image(effect).get_data()
sd = load_image(sd).get_data()
var = sd ** 2
# The optimal, in terms of minimum variance, combination of the
# effects has weights 1 / var
#
# XXX regions with 0 variance are set to 0
# XXX do we want this or np.nan?
ivar = np.nan_to_num(1. / var)
fixed_effect += effect * ivar
fixed_var += ivar
# Now, compute the fixed effects variance and t statistic
fixed_sd = np.sqrt(fixed_var)
isd = np.nan_to_num(1. / fixed_sd)
fixed_t = fixed_effect * isd
# Save the results
odir = futil.ensure_dir(fixdir, con)
for a, n in zip([fixed_effect, fixed_sd, fixed_t],
['effect', 'sd', 't']):
im = api.Image(a, copy(coordmap))
save_image(im, pjoin(odir, '%s.nii' % n))
def get_fmri_anat(path_dict):
"""Get the images for a given subject/run.
Returns
-------
fmri : ndarray
anat : NIPY image
"""
fmri = np.array(load_image(pjoin("%(rootdir)s/swafunctional_%(run)02d.nii") % path_dict))
anat = load_image(pjoin(DATADIR, "fiac_%(subj)02d", "wanatomical.nii") % path_dict)
return fmri, anat
def test_write():
fp, fname = mkstemp('.nii')
img = load_image(funcfile)
save_image(img, fname)
test = FmriImageList.from_image(load_image(fname))
yield nose.tools.assert_equal, test[0].affine.shape, (4,4)
yield nose.tools.assert_equal, img[0].affine.shape, (5,4)
yield nose.tools.assert_true, np.allclose(test[0].affine, img[0].affine[1:])
# Under windows, if you don't close before delete, you get a
# locking error.
os.close(fp)
os.remove(fname)
def setUp(self):
self.fd = np.asarray(load_image(funcfile))
self.fi = FmriImageList.from_image(load_image(funcfile))
# I think it makes more sense to use fd instead of fi for GLM
# purposes -- reduces some noticeable overhead in creating the
# array from FmriImageList
# create a design matrix, model and contrast matrix
self.design = noise((self.fd.shape[0],3))
self.model = ols_model(self.design)
self.cmatrix = np.array([[1,0,0],[0,1,0]])
def test_write():
fname = 'myfile.nii'
img = load_image(funcfile)
with InTemporaryDirectory():
save_image(img, fname)
test = FmriImageList.from_image(load_image(fname))
assert_equal(test[0].affine.shape, (4,4))
assert_equal(img[0].affine.shape, (5,4))
# Check the affine...
A = np.identity(4)
A[:3,:3] = img[:,:,:,0].affine[:3,:3]
A[:3,-1] = img[:,:,:,0].affine[:3,-1]
assert_true(np.allclose(test[0].affine, A))
del test
def test_write():
fname = "myfile.nii"
img = load_image(funcfile)
with InTemporaryDirectory():
save_image(img, fname)
test = FmriImageList.from_image(load_image(fname))
assert_equal(test[0].affine.shape, (4, 4))
assert_equal(img[0].affine.shape, (5, 4))
# Check the affine...
A = np.identity(4)
A[:3, :3] = img[:, :, :, 0].affine[:3, :3]
A[:3, -1] = img[:, :, :, 0].affine[:3, -1]
assert_true(np.allclose(test[0].affine, A))
del test
def test_space_time_realign():
path, fname = psplit(funcfile)
original_affine = load_image(funcfile).affine
path, fname = psplit(funcfile)
froot, _ = fname.split('.', 1)
with InTemporaryDirectory():
# Make another image with .nii extension and extra dot in filename
save_image(load_image(funcfile), 'my.test.nii')
for in_fname, out_fname in ((funcfile, froot + '_mc.nii.gz'),
('my.test.nii', 'my.test_mc.nii.gz')):
xforms = reg.space_time_realign(in_fname, 2.0, out_name='.')
assert_true(np.allclose(xforms[0].as_affine(), np.eye(4), atol=1e-7))
assert_false(np.allclose(xforms[-1].as_affine(), np.eye(4), atol=1e-3))
img = load_image(out_fname)
npt.assert_almost_equal(original_affine, img.affine)
def group_analysis(design, contrast):
"""
Compute group analysis effect, sd and t
for a given contrast and design type
"""
array = np.array # shorthand
# Directory where output will be written
odir = futil.ensure_dir(futil.DATADIR, 'group', design, contrast)
# Which subjects have this (contrast, design) pair?
subjects = futil.subject_dirs(design, contrast)
sd = array([array(load_image(pjoin(s, "sd.nii"))) for s in subjects])
Y = array([array(load_image(pjoin(s, "effect.nii"))) for s in subjects])
# This function estimates the ratio of the
# fixed effects variance (sum(1/sd**2, 0))
# to the estimated random effects variance
# (sum(1/(sd+rvar)**2, 0)) where
# rvar is the random effects variance.
# The EM algorithm used is described in
#
# Worsley, K.J., Liao, C., Aston, J., Petre, V., Duncan, G.H.,
# Morales, F., Evans, A.C. (2002). \'A general statistical
# analysis for fMRI data\'. NeuroImage, 15:1-15
varest = onesample.estimate_varatio(Y, sd)
random_var = varest['random']
# XXX - if we have a smoother, use
# random_var = varest['fixed'] * smooth(varest['ratio'])
# Having estimated the random effects variance (and
# possibly smoothed it), the corresponding
# estimate of the effect and its variance is
# computed and saved.
# This is the coordmap we will use
coordmap = futil.load_image_fiac("fiac_00","wanatomical.nii").coordmap
adjusted_var = sd**2 + random_var
adjusted_sd = np.sqrt(adjusted_var)
results = onesample.estimate_mean(Y, adjusted_sd)
for n in ['effect', 'sd', 't']:
im = api.Image(results[n], coordmap.copy())
save_image(im, pjoin(odir, "%s.nii" % n))
def fixed_effects(subj, design):
"""
Fixed effects (within subject) for FIAC model
"""
# First, find all the effect and standard deviation images
# for the subject and this design type
path_dict = futil.path_info2(subj, design)
rootdir = path_dict['rootdir']
# The output directory
fixdir = pjoin(rootdir, "fixed")
results = futil.results_table(path_dict)
# Get our hands on the relevant coordmap to
# save our results
coordmap = futil.load_image_fiac("fiac_%02d" % subj,
"wanatomical.nii").coordmap
# Compute the "fixed" effects for each type of contrast
for con in results:
fixed_effect = 0
fixed_var = 0
for effect, sd in results[con]:
effect = load_image(effect); sd = load_image(sd)
var = np.array(sd)**2
# The optimal, in terms of minimum variance, combination of the
# effects has weights 1 / var
#
# XXX regions with 0 variance are set to 0
# XXX do we want this or np.nan?
ivar = np.nan_to_num(1. / var)
fixed_effect += effect * ivar
fixed_var += ivar
# Now, compute the fixed effects variance and t statistic
fixed_sd = np.sqrt(fixed_var)
isd = np.nan_to_num(1. / fixed_sd)
fixed_t = fixed_effect * isd
# Save the results
odir = futil.ensure_dir(fixdir, con)
for a, n in zip([fixed_effect, fixed_sd, fixed_t],
['effect', 'sd', 't']):
im = api.Image(a, coordmap.copy())
save_image(im, pjoin(odir, '%s.nii' % n))
def test_save3():
# A test to ensure that when a file is saved, the affine
# and the data agree. In this case, things don't agree:
# i) the pixdim is off
# ii) makes the affine off
step = np.array([3.45,2.3,4.5,6.9])
shape = (13,5,7,3)
mni_xyz = mni_csm(3).coord_names
cmap = AT(CS('jkli'),
CS(('t',) + mni_xyz[::-1]),
from_matvec(np.diag([0,3,5,1]), step))
data = np.random.standard_normal(shape)
img = api.Image(data, cmap)
# with InTemporaryDirectory():
with InTemporaryDirectory():
save_image(img, TMP_FNAME)
tmp = load_image(TMP_FNAME)
# Detach image from file so we can delete it
data = tmp.get_data().copy()
img2 = api.Image(data, tmp.coordmap, tmp.metadata)
del tmp
assert_equal(tuple([img.shape[l] for l in [3,2,1,0]]), img2.shape)
a = np.transpose(np.asarray(img), [3,2,1,0])
assert_false(np.allclose(img.affine, img2.affine))
assert_true(np.allclose(a, img2.get_data()))
def permutation_test(design, contrast, mask=GROUP_MASK, nsample=1000):
"""
Perform a permutation (sign) test for a given design type and
contrast. It is a Monte Carlo test because we only sample nsample
possible sign arrays.
Parameters
----------
design: one of ['block', 'event']
contrast: str
nsample: int
Returns
-------
min_vals: np.ndarray
max_vals: np.ndarray
"""
maska = np.asarray(mask).astype(np.bool)
subjects = futil.subject_dirs(design, contrast)
Y = np.array([np.array(load_image(pjoin(s, "effect.nii")))[:,maska]
for s in subjects])
nsubj = Y.shape[0]
signs = 2*np.greater(np.random.sample(size=(nsample, nsubj)), 0.5) - 1
min_vals, max_vals = group_analysis_signs(design, contrast, maska, signs)
return min_vals, max_vals
def setup():
tmp_img = load_image(funcfile)
# For now, img is an Image
# instead of an XYZImage
A = np.identity(4)
A[:3,:3] = tmp_img.affine[:3,:3]
A[:3,-1] = tmp_img.affine[:3,-1]
xyz_data = tmp_img.get_data()
xyz_img = XYZImage(xyz_data, A,
tmp_img.axes.coord_names[:3] + ('t',))
# If load_image returns an XYZImage, I'd really be
# starting from xyz_img, so from here
# Here, I'm just doing this so I know that
# img.shape[0] is the number of volumes
img = image_rollaxis(Image(xyz_img._data, xyz_img.coordmap), 't')
data_dict['nimages'] = img.shape[0]
# It might be worth to make
# data a public attribute of Image/XYZImage
# and we might rename get_data-> data_as_array = np.asarray(self.data)
# Then, the above would not access a private attribute
# Below, I am just making a mask
# because I already have img, I
# know I can do this
# In principle, though, the pca function
# will just take another XYZImage as a mask
img_data = img.get_data()
first_frame = img_data[0]
mask = XYZImage(np.greater(np.asarray(first_frame), 500).astype(np.float64), A, xyz_img.axes.coord_names[:3])
data_dict['fmridata'] = xyz_img
data_dict['mask'] = mask
data_dict['img'] = img
print data_dict['mask'].shape, np.sum(np.array(data_dict['mask']))
def test_subcoordmap():
img = load_image(funcfile)
subcoordmap = img[3].coordmap
xform = img.coordmap.affine[:,1:]
nose.tools.assert_true(np.allclose(subcoordmap.affine[1:], xform[1:]))
## XXX FIXME: why is it [0,0] entry instead of [0] below?
nose.tools.assert_true(np.allclose(subcoordmap.affine[0], [0,0,0,img.coordmap([3,0,0,0])[0,0]]))
def test_save2b():
# A test to ensure that when a file is saved, the affine and the
# data agree. This image comes from a NIFTI file This example has
# a non-diagonal affine matrix for the spatial part, but is
# 'diagonal' for the space part. this should raise a warnings
# about 'non-diagonal' affine matrix
# make a 5x5 transformatio
step = np.array([3.45,2.3,4.5,6.9])
A = np.random.standard_normal((4,4))
B = np.diag(list(step)+[1])
B[:4,:4] = A
shape = (13,5,7,3)
cmap = api.AffineTransform.from_params('ijkt', 'xyzt', B)
data = np.random.standard_normal(shape)
img = api.Image(data, cmap)
save_image(img, tmpfile.name)
img2 = load_image(tmpfile.name)
yield assert_false, np.allclose(img.affine, img2.affine)
yield assert_true, np.allclose(img.affine[:3,:3], img2.affine[:3,:3])
yield assert_equal, img.shape, img2.shape
yield assert_true, np.allclose(np.asarray(img2), np.asarray(img))
def adj_from_nii(maskfile,
num_time_points,
numt=0,
numx=1,
numy=1,
numz=1,
regions=None):
"""
Construct adjacency array from .nii mask file
INPUT:
maskfile: Path to mask file (.nii)
Other parameters are passed directly to prepare_adj (see that function for docs)
OUTPUT:
adj: An array containing adjacency information
"""
mask = load_image(maskfile)._data
newmask = np.zeros(np.append(num_time_points, mask.shape))
for i in range(num_time_points):
newmask[i] = mask
adj = prepare_adj(newmask, numt, numx, numy, numz, regions)
adj = convert_to_array(adj)
return adj
def test_model_out_img():
# Model output image
cmap = load_image(anatfile).coordmap
shape = (2,3,4)
fname = 'myfile.nii'
with InTemporaryDirectory():
moi = ModelOutputImage(fname, cmap, shape)
for i in range(shape[0]):
moi[i] = i
for i in range(shape[0]):
assert_array_equal(moi[i], i)
moi.save()
assert_raises(ValueError, moi.__setitem__, 0, 1)
assert_raises(ValueError, moi.__getitem__, 0)
new_img = load_image(fname)
for i in range(shape[0]):
assert_array_equal(new_img[i].get_data(), i)
def test_labels1():
img = load_image(funcfile)
parcelmap = fromarray(np.asarray(img[0]), 'kji', 'zyx')
parcelmap = (np.asarray(parcelmap) * 100).astype(np.int32)
v = 0
for i, d in fmri_generator(img, parcels(parcelmap)):
v += d.shape[1]
assert_equal(v, parcelmap.size)
def test_subcoordmap():
img = load_image(funcfile)
subcoordmap = img[3].coordmap
xform = img.affine[:, 1:]
assert_true(np.allclose(subcoordmap.affine[1:], xform[1:]))
assert_true(
np.allclose(subcoordmap.affine[0],
[0, 0, 0, img.coordmap([3, 0, 0, 0])[0]]))
def setup():
img = load_image(funcfile)
arr = img.get_data()
#arr = np.rollaxis(arr, 3)
data['nimages'] = arr.shape[3]
data['fmridata'] = arr
frame = data['fmridata'][...,0]
data['mask'] = (frame > 500).astype(np.float64)
def test_space_time_realign():
path, fname = psplit(funcfile)
original_affine = load_image(funcfile).affine
path, fname = psplit(funcfile)
froot, _ = fname.split('.', 1)
with InTemporaryDirectory():
# Make another image with .nii extension and extra dot in filename
save_image(load_image(funcfile), 'my.test.nii')
for in_fname, out_fname in ((funcfile, froot + '_mc.nii.gz'),
('my.test.nii', 'my.test_mc.nii.gz')):
xforms = reg.space_time_realign(in_fname, 2.0, out_name='.')
assert_true(
np.allclose(xforms[0].as_affine(), np.eye(4), atol=1e-7))
assert_false(
np.allclose(xforms[-1].as_affine(), np.eye(4), atol=1e-3))
img = load_image(out_fname)
npt.assert_almost_equal(original_affine, img.affine)
def setup():
img = load_image(funcfile)
arr = np.array(img)
#arr = np.rollaxis(arr, 3)
data['nimages'] = arr.shape[3]
data['fmridata'] = arr
frame = data['fmridata'][...,0]
data['mask'] = (frame > 500).astype(np.float64)
def test_labels1():
img = load_image(funcfile)
data = img.get_data()
parcelmap = Image(img[0].get_data(), AfT("kji", "zyx", np.eye(4)))
parcelmap = (parcelmap.get_data() * 100).astype(np.int32)
v = 0
for i, d in axis0_generator(data, parcels(parcelmap)):
v += d.shape[1]
assert_equal(v, parcelmap.size)
def test_write():
fp, fname = mkstemp('.nii')
img = load_image(funcfile)
save_image(img, fname)
test = FmriImageList.from_image(load_image(fname))
yield assert_equal, test[0].affine.shape, (4,4)
yield assert_equal, img[0].affine.shape, (5,4)
# Check the affine...
A = np.identity(4)
A[:3,:3] = img[:,:,:,0].affine[:3,:3]
A[:3,-1] = img[:,:,:,0].affine[:3,-1]
yield assert_true, np.allclose(test[0].affine, A)
# Under windows, if you don't close before delete, you get a
# locking error.
os.close(fp)
os.remove(fname)
def test_model_out_img():
# Model output image
cmap = load_image(anatfile).coordmap
shape = (2, 3, 4)
fname = 'myfile.nii'
with InTemporaryDirectory():
moi = ModelOutputImage(fname, cmap, shape)
for i in range(shape[0]):
moi[i] = i
for i in range(shape[0]):
assert_array_equal(moi[i], i)
moi.save()
assert_raises(ValueError, moi.__setitem__, 0, 1)
assert_raises(ValueError, moi.__getitem__, 0)
new_img = load_image(fname)
for i in range(shape[0]):
assert_array_equal(new_img[i].get_data(), i)
del new_img
def test_labels1():
img = load_image(funcfile)
data = img.get_data()
parcelmap = Image(img[0].get_data(), AfT('kji', 'zyx', np.eye(4)))
parcelmap = (parcelmap.get_data() * 100).astype(np.int32)
v = 0
for i, d in axis0_generator(data, parcels(parcelmap)):
v += d.shape[1]
assert_equal(v, parcelmap.size)
def test_image_list():
img = load_image(funcfile)
exp_shape = (17, 21, 3, 20)
imglst = ImageList.from_image(img, axis=-1)
# Test empty ImageList
emplst = ImageList()
yield assert_equal(len(emplst.list), 0)
# Test non-image construction
a = np.arange(10)
yield assert_raises(ValueError, ImageList, a)
yield assert_raises(ValueError, ImageList.from_image, img, None)
# check all the axes
for i in range(4):
order = range(4)
order.remove(i)
order.insert(0,i)
img_re_i = img.reordered_reference(order).reordered_axes(order)
imglst_i = ImageList.from_image(img, axis=i)
yield assert_equal(imglst_i.list[0].shape, img_re_i.shape[1:])
# check the affine as well
yield assert_almost_equal(imglst_i.list[0].affine,
img_re_i.affine[1:,1:])
yield assert_equal(img.shape, exp_shape)
# length of image list should match number of frames
yield assert_equal(len(imglst.list), img.shape[3])
# check the affine
A = np.identity(4)
A[:3,:3] = img.affine[:3,:3]
A[:3,-1] = img.affine[:3,-1]
yield assert_almost_equal(imglst.list[0].affine, A)
# Slicing an ImageList should return an ImageList
sublist = imglst[2:5]
yield assert_true(isinstance(sublist, ImageList))
# Except when we're indexing one element
yield assert_true(isinstance(imglst[0], Image))
# Verify array interface
# test __array__
yield assert_true(isinstance(np.asarray(sublist), np.ndarray))
# Test __setitem__
sublist[2] = sublist[0]
yield assert_equal(np.asarray(sublist[0]).mean(),
np.asarray(sublist[2]).mean())
# Test iterator
for x in sublist:
yield assert_true(isinstance(x, Image))
yield assert_equal(x.shape, exp_shape[:3])
def test_iter():
img = load_image(funcfile)
img_shape = img.shape
exp_shape = (img_shape[0],) + img_shape[2:]
j = 0
for i, d in axis0_generator(img.get_data()):
j += 1
assert_equal(d.shape, exp_shape)
del(i); gc.collect()
assert_equal(j, img_shape[1])
def compare_results(subj, run, other_root, mask_fname):
""" Find and compare calculated results images from a previous run
This scipt checks that another directory containing results of this same
analysis are similar in the sense of numpy ``allclose`` within a brain mask.
Parameters
----------
subj : int
subject number (1..6)
run : int
run number (1..12)
other_root : str
path to previous run estimation
mask_fname:
path to a mask image defining area in which to compare differences
"""
# Get information for this subject and run
path_dict = path_info_run(subj, run)
# Get mask
msk = load_image(mask_fname).get_data().copy().astype(bool)
# Get results directories for this run
rootdir = path_dict['rootdir']
res_dir = pjoin(rootdir, 'results_run%03d' % run)
if not isdir(res_dir):
return
for dirpath, dirnames, filenames in os.walk(res_dir):
for fname in filenames:
froot, ext = splitext(fname)
if froot in ('effect', 'sd', 'F', 't'):
this_fname = pjoin(dirpath, fname)
other_fname = this_fname.replace(DATADIR, other_root)
if not exists(other_fname):
print(this_fname, 'present but ', other_fname, 'missing')
continue
this_arr = load_image(this_fname).get_data()
other_arr = load_image(other_fname).get_data()
ok = np.allclose(this_arr[msk], other_arr[msk])
if not ok and froot in ('effect', 'sd',
't'): # Maybe a sign flip
ok = np.allclose(this_arr[msk], -other_arr[msk])
if not ok:
print('Difference between', this_fname, other_fname)
def test_iter():
img = load_image(funcfile)
img_shape = img.shape
exp_shape = (img_shape[0],) + img_shape[2:]
j = 0
for i, d in fmri_generator(img):
j += 1
yield assert_equal(d.shape, exp_shape)
del(i); gc.collect()
yield assert_equal(j, img_shape[1])
def test_iter():
img = load_image(funcfile)
img_shape = img.shape
exp_shape = (img_shape[0],) + img_shape[2:]
j = 0
for i, d in axis0_generator(img.get_data()):
j += 1
assert_equal(d.shape, exp_shape)
del(i); gc.collect()
assert_equal(j, img_shape[1])
def compare_results(subj, run, other_root, mask_fname):
""" Find and compare calculated results images from a previous run
This scipt checks that another directory containing results of this same
analysis are similar in the sense of numpy ``allclose`` within a brain mask.
Parameters
----------
subj : int
subject number (0..4, 6..15)
run : int
run number (1..4)
other_root : str
path to previous run estimation
mask_fname:
path to a mask image defining area in which to compare differences
"""
# Get information for this subject and run
path_dict = path_info_run(subj, run)
# Get mask
msk = load_image(mask_fname).get_data().copy().astype(bool)
# Get results directories for this run
rootdir = path_dict['rootdir']
res_dir = pjoin(rootdir, 'results_%02d' % run)
if not isdir(res_dir):
return
for dirpath, dirnames, filenames in os.walk(res_dir):
for fname in filenames:
froot, ext = splitext(fname)
if froot in ('effect', 'sd', 'F', 't'):
this_fname = pjoin(dirpath, fname)
other_fname = this_fname.replace(DATADIR, other_root)
if not exists(other_fname):
print(this_fname, 'present but ', other_fname, 'missing')
continue
this_arr = load_image(this_fname).get_data()
other_arr = load_image(other_fname).get_data()
ok = np.allclose(this_arr[msk], other_arr[msk])
if not ok and froot in ('effect', 'sd', 't'): # Maybe a sign flip
ok = np.allclose(this_arr[msk], -other_arr[msk])
if not ok:
print('Difference between', this_fname, other_fname)
def test_is_image():
# tests for tests for image
img = load_image(anatfile)
yield assert_true(is_image(img))
class C(object): pass
yield assert_false(is_image(C()))
class C(object):
def __array__(self): pass
yield assert_false(is_image(C()))
class C(object):
coordmap = None
def __array__(self): pass
yield assert_true(is_image(img))
def get_fmri(path_dict):
"""Get the images for a given subject/run.
Returns
-------
fmri : ndarray
anat : NIPY image
"""
fmri_im = load_image(
pjoin("%(rootdir)s/swafunctional_%(run)02d.nii") % path_dict)
# Make sure we know the order of the coordinates
fmri_im = fmri_im.reordered_world('xyzt').reordered_axes('ijkl')
return fmri_im
def test_save4():
# Same as test_save3 except we have reordered the 'ijk' input axes.
shape = (13,5,7,3)
step = np.array([3.45,2.3,4.5,6.9])
# When the input coords are in the 'ljki' order, the affines get
# rearranged. Note that the 'start' below, must be 0 for
# non-spatial dimensions, because we have no way to store them in
# most cases. For example, a 'start' of [1,5,3,1] would be lost on
# reload
cmap = api.Affine.from_start_step('lkji', 'tzyx', [2,5,3,1], step)
data = np.random.standard_normal(shape)
img = api.Image(data, cmap)
save_image(img, tmpfile.name)
img2 = load_image(tmpfile.name)
P = np.array([[0,0,0,1,0],
[0,0,1,0,0],
[0,1,0,0,0],
[1,0,0,0,0],
[0,0,0,0,1]])
res = np.dot(P, np.dot(img.affine, P.T))
# the step part of the affine should be set correctly
yield assert_array_almost_equal, res[:4,:4], img2.affine[:4,:4]
# start in the spatial dimensions should be set correctly
yield assert_array_almost_equal, res[:3,-1], img2.affine[:3,-1]
# start in the time dimension should not be 2 as in img, but 0
# because NIFTI dosen't have a time start
yield assert_false, (res[3,-1] == img2.affine[3,-1])
yield assert_true, (res[3,-1] == 2)
yield assert_true, (img2.affine[3,-1] == 0)
# shapes should be reversed because img has coordinates reversed
yield assert_equal, img.shape[::-1], img2.shape
# data should be transposed because coordinates are reversed
yield (assert_array_almost_equal,
np.transpose(np.asarray(img2),[3,2,1,0]),
np.asarray(img))
# coordinate names should be reversed as well
yield assert_equal, img2.coordmap.input_coords.coord_names, \
img.coordmap.input_coords.coord_names[::-1]
yield assert_equal, img2.coordmap.input_coords.coord_names, \
['i', 'j', 'k', 'l']
def get_fmri(path_dict):
"""Get the images for a given subject/run.
Parameters
----------
path_dict : dict
containing key 'rootdir', 'run'
Returns
-------
fmri : ndarray
anat : NIPY image
"""
fmri_im = load_image(
pjoin("%(rootdir)s/swafunctional_%(run)02d.nii") % path_dict)
return fmri_im
def get_fmri(path_dict):
"""Get the images for a given subject/run.
Parameters
----------
path_dict : dict
containing key 'fsldir', 'run'
Returns
-------
fmri : ndarray
anat : NIPY image
"""
fmri_im = load_image(
pjoin("%(fsldir)s/task001_run%(run)03d.feat/filtered_func_data.nii.gz") % path_dict)
return fmri_im
def test_save2():
# A test to ensure that when a file is saved, the affine and the
# data agree. This image comes from a NIFTI file
shape = (13, 5, 7, 3)
step = np.array([3.45, 2.3, 4.5, 6.93])
cmap = api.AffineTransform.from_start_step('ijkt', 'xyzt', [1, 3, 5, 0],
step)
data = np.random.standard_normal(shape)
img = api.Image(data, cmap)
with InTemporaryDirectory():
save_image(img, TMP_FNAME)
img2 = load_image(TMP_FNAME)
assert_array_almost_equal(img.affine, img2.affine)
assert_equal(img.shape, img2.shape)
assert_array_almost_equal(img2.get_data(), img.get_data())
del img2
def seg_recovery(y_pred, filename):
label = load_image(PRE_LABEL_PATH + filename)
shape = label.get_data().shape
segment = np.zeros(shape)
h1 = y_pred[0].around()
h2 = y_pred[1].around()
area = crop_setting['3d' + str(shape[2])]
segment[area['x'][0]:area['x'][1], area['y'][0]:area['y'][1],
area['z1'][0]:area['z1'][1], 0] = h1[0]
segment[area['x'][0]:area['x'][1], area['y'][0]:area['y'][1],
area['z2'][0]:area['z2'][1], 1] = h2[0]
img = Image(segment, label.coordmap)
save_image(img, OUTPUT + filename)
def adj_from_nii(maskfile,
num_time_points,
numt=0,
numx=1,
numy=1,
numz=1,
regions=None):
from nipy.io.api import load_image
from nipy.core.api import Image
mask = load_image(maskfile)._data
return adj_from_3dmask(mask=mask,
num_time_points=num_time_points,
numt=numt,
numx=numx,
numy=numy,
numz=numz,
regions=regions)
def test_run():
ar1_fname = 'ar1_out.nii'
funcim = load_image(funcfile)
fmriims = FmriImageList.from_image(funcim, volume_start_times=2.)
one_vol = fmriims[0]
# Formula - with an intercept
t = Term('t')
f = Formula([t, t**2, t**3, 1])
# Design matrix and contrasts
time_vector = make_recarray(fmriims.volume_start_times, 't')
con_defs = dict(c=t, c2=t + t**2)
desmtx, cmatrices = f.design(time_vector, contrasts=con_defs)
# Run with Image and ImageList
for inp_img in (rollimg(funcim, 't'), fmriims):
with InTemporaryDirectory():
# Run OLS model
outputs = []
outputs.append(model.output_AR1(ar1_fname, fmriims))
outputs.append(model.output_resid('resid_OLS_out.nii', fmriims))
ols = model.OLS(fmriims, f, outputs)
ols.execute()
# Run AR1 model
outputs = []
outputs.append(model.output_T('T_out.nii', cmatrices['c'],
fmriims))
outputs.append(
model.output_F('F_out.nii', cmatrices['c2'], fmriims))
outputs.append(model.output_resid('resid_AR_out.nii', fmriims))
rho = load_image(ar1_fname)
ar = model.AR1(fmriims, f, rho, outputs)
ar.execute()
f_img = load_image('F_out.nii')
assert_equal(f_img.shape, one_vol.shape)
f_data = f_img.get_data()
assert_true(np.all((f_data >= 0) & (f_data < 30)))
resid_img = load_image('resid_AR_out.nii')
assert_equal(resid_img.shape, funcim.shape)
assert_array_almost_equal(np.mean(resid_img.get_data()), 0, 3)
e_img = load_image('T_out_effect.nii')
sd_img = load_image('T_out_sd.nii')
t_img = load_image('T_out_t.nii')
t_data = t_img.get_data()
assert_array_almost_equal(t_data,
e_img.get_data() / sd_img.get_data())
assert_true(np.all(np.abs(t_data) < 6))
# Need to delete to help windows delete temporary files
del rho, resid_img, f_img, e_img, sd_img, t_img, f_data, t_data
def test_save4():
# Same as test_save3 except we have reordered the 'ijk' input axes.
shape = (13, 5, 7, 3)
step = np.array([3.45, 2.3, 4.5, 6.9])
# When the input coords are in the 'ljki' order, the affines get
# rearranged. Note that the 'start' below, must be 0 for
# non-spatial dimensions, because we have no way to store them in
# most cases. For example, a 'start' of [1,5,3,1] would be lost on
# reload
mni_xyz = mni_csm(3).coord_names
cmap = AT(CS('tkji'), CS((('t', ) + mni_xyz[::-1])),
from_matvec(np.diag([2., 3, 5, 1]), step))
data = np.random.standard_normal(shape)
img = api.Image(data, cmap)
with InTemporaryDirectory():
save_image(img, TMP_FNAME)
tmp = load_image(TMP_FNAME)
data = tmp.get_data().copy()
# Detach image from file so we can delete it
img2 = api.Image(data, tmp.coordmap, tmp.metadata)
del tmp
P = np.array([[0, 0, 0, 1, 0], [0, 0, 1, 0, 0], [0, 1, 0, 0, 0],
[1, 0, 0, 0, 0], [0, 0, 0, 0, 1]])
res = np.dot(P, np.dot(img.affine, P.T))
# the step part of the affine should be set correctly
assert_array_almost_equal(res[:4, :4], img2.affine[:4, :4])
# start in the spatial dimensions should be set correctly
assert_array_almost_equal(res[:3, -1], img2.affine[:3, -1])
# start in the time dimension should be 3.45 as in img, because NIFTI stores
# the time offset in hdr[``toffset``]
assert_not_equal(res[3, -1], img2.affine[3, -1])
assert_equal(res[3, -1], 3.45)
# shapes should be reversed because img has coordinates reversed
assert_equal(img.shape[::-1], img2.shape)
# data should be transposed because coordinates are reversed
assert_array_almost_equal(np.transpose(img2.get_data(), [3, 2, 1, 0]),
img.get_data())
# coordinate names should be reversed as well
assert_equal(img2.coordmap.function_domain.coord_names,
img.coordmap.function_domain.coord_names[::-1])
assert_equal(img2.coordmap.function_domain.coord_names,
('i', 'j', 'k', 't'))
def test_save2b():
# A test to ensure that when a file is saved, the affine and the
# data agree. This image comes from a NIFTI file. This example has a
# non-diagonal affine matrix for the spatial part, but is 'diagonal' for the
# space part.
#
# make a 5x5 transformation (for 4d image)
step = np.array([3.45, 2.3, 4.5, 6.9])
A = np.random.standard_normal((3, 3))
B = np.diag(list(step) + [1])
B[:3, :3] = A
shape = (13, 5, 7, 3)
cmap = api.vox2mni(B)
data = np.random.standard_normal(shape)
img = api.Image(data, cmap)
with InTemporaryDirectory():
save_image(img, TMP_FNAME)
img2 = load_image(TMP_FNAME)
assert_array_almost_equal(img.affine, img2.affine)
assert_equal(img.shape, img2.shape)
assert_array_almost_equal(img2.get_data(), img.get_data())
del img2
def test_save3():
# A test to ensure that when a file is saved, the affine
# and the data agree. In this case, things don't agree:
# i) the pixdim is off
# ii) makes the affine off
step = np.array([3.45, 2.3, 4.5, 6.9])
shape = (13, 5, 7, 3)
mni_xyz = mni_csm(3).coord_names
cmap = AT(CS('jkli'), CS(('t', ) + mni_xyz[::-1]),
from_matvec(np.diag([0, 3, 5, 1]), step))
data = np.random.standard_normal(shape)
img = api.Image(data, cmap)
# with InTemporaryDirectory():
with InTemporaryDirectory():
save_image(img, TMP_FNAME)
tmp = load_image(TMP_FNAME)
# Detach image from file so we can delete it
data = tmp.get_data().copy()
img2 = api.Image(data, tmp.coordmap, tmp.metadata)
del tmp
assert_equal(tuple([img.shape[l] for l in [3, 2, 1, 0]]), img2.shape)
a = np.transpose(img.get_data(), [3, 2, 1, 0])
assert_false(np.allclose(img.affine, img2.affine))
assert_true(np.allclose(a, img2.get_data()))
import os
from mgni.smooth import smooth
import json
mode = 'SVR' # SVC or SVR
root = '/data/fmri/simu/'
# roi_name = '%s_Fusiform_posterior_AAL.nii' % mode
roi_name = '%s_wholebrain.nii' % mode
mask = '/home/matteo/science/fmri/roi/example_mask.nii'
roi = '/home/matteo/science/fmri/roi/example_mask.nii'
# roi = '/home/matteo/science/fmri/roi/AAL/rFusiform_posterior_AAL.nii'
n_subjects = 16
fwhm = 10
img_mask = load_image(mask)
img_mask = Image(img_mask.get_data().astype(np.float64), img_mask.coordmap,
img_mask.header)
img_roi = load_image(roi)
img_roi = Image(img_roi.get_data().astype(np.float64), img_roi.coordmap,
img_roi.header)
ind_roi = img_roi.get_data().astype(bool) & img_mask.get_data().astype(bool)
ind_noroi = ~img_roi.get_data().astype(bool) & img_mask.get_data().astype(bool)
roi_data = np.random.randn(np.sum(ind_roi))
for i in range(1, n_subjects + 1):
print('subject %02g' % i)
s_dir = os.path.join(root, '%02g' % i)
def load_image(self, filename):
self.img = load_image(filename)
self.filename = filename
print 'Opening file:', filename
self.axes_order = self._axes_order_from_orientation()
self.update_data()
def group_analysis_signs(design, contrast, mask, signs=None):
""" Refit the EM model with a vector of signs.
Used in the permutation tests.
Returns the maximum of the T-statistic within mask
Parameters
----------
design: one of 'block', 'event'
contrast: str
name of contrast to estimate
mask : ``Image`` instance or array-like
image containing mask, or array-like
signs: ndarray, optional
Defaults to np.ones. Should have shape (*,nsubj)
where nsubj is the number of effects combined in the group analysis.
Returns
-------
minT: np.ndarray, minima of T statistic within mask, one for each
vector of signs
maxT: np.ndarray, maxima of T statistic within mask, one for each
vector of signs
"""
if api.is_image(mask):
maska = mask.get_data()
else:
maska = np.asarray(mask)
maska = maska.astype(np.bool)
# Which subjects have this (contrast, design) pair?
subj_con_dirs = futil.subj_des_con_dirs(design, contrast)
# Assemble effects and sds into 4D arrays
sds = []
Ys = []
for s in subj_con_dirs:
sd_img = load_image(pjoin(s, "sd.nii"))
effect_img = load_image(pjoin(s, "effect.nii"))
sds.append(sd_img.get_data()[maska])
Ys.append(effect_img.get_data()[maska])
sd = np.array(sds)
Y = np.array(Ys)
if signs is None:
signs = np.ones((1, Y.shape[0]))
maxT = np.empty(signs.shape[0])
minT = np.empty(signs.shape[0])
for i, sign in enumerate(signs):
signY = sign[:, np.newaxis] * Y
varest = onesample.estimate_varatio(signY, sd)
random_var = varest['random']
adjusted_var = sd**2 + random_var
adjusted_sd = np.sqrt(adjusted_var)
results = onesample.estimate_mean(Y, adjusted_sd)
T = results['t']
minT[i], maxT[i] = np.nanmin(T), np.nanmax(T)
return minT, maxT
def test_resample_img2img():
fimg = load_image(funcfile)
aimg = load_image(anatfile)
resimg = resample_img2img(fimg, fimg)
yield assert_true, np.allclose(resimg.get_data(), fimg.get_data())
yield assert_raises, ValueError, resample_img2img, fimg, aimg
from numpy.testing import assert_array_almost_equal
from nipy.testing import funcfile
def setup():
# Suppress warnings during tests to reduce noise
warnings.simplefilter("ignore")
def teardown():
# Clear list of warning filters
warnings.resetwarnings()
# Module globals
FIMG = load_image(funcfile)
# Put time on first axis
FIMG = rollimg(FIMG, 't')
FDATA = FIMG.get_data()
FIL = FmriImageList.from_image(FIMG)
# I think it makes more sense to use FDATA instead of FIL for GLM
# purposes -- reduces some noticeable overhead in creating the
# array from FmriImageList
# create a design matrix, model and contrast matrix
DESIGN = noise((FDATA.shape[0], 3))
MODEL = OLSModel(DESIGN)
CMATRIX = np.array([[1, 0, 0], [0, 1, 0]])
def load_image_ds105(*path):
"""Return a NIPY image from a set of path components.
"""
return load_image(pjoin(DATADIR, *path))
