def test_2d_eq_4d():
arr4d = data['fmridata']
shp = arr4d.shape
arr2d = arr4d.reshape((np.prod(shp[:3]), shp[3]))
arr3d = arr4d.reshape((shp[0], -1, shp[3]))
res4d = pos1pca(arr4d, axis=-1, standardize=False)
res3d = pos1pca(arr3d, axis=-1, standardize=False)
res2d = pos1pca(arr2d, axis=-1, standardize=False)
assert_array_almost_equal(res4d['basis_vectors'], res2d['basis_vectors'])
assert_array_almost_equal(res4d['basis_vectors'], res3d['basis_vectors'])
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_2d_eq_4d():
arr4d = data['fmridata']
shp = arr4d.shape
arr2d = arr4d.reshape((np.prod(shp[:3]), shp[3]))
arr3d = arr4d.reshape((shp[0], -1, shp[3]))
res4d = pca(arr4d, axis=-1, standardize=False)
res3d = pca(arr3d, axis=-1, standardize=False)
res2d = pca(arr2d, axis=-1, standardize=False)
assert_array_almost_equal(pos1basis(res4d),
pos1basis(res2d))
assert_array_almost_equal(pos1basis(res4d),
pos1basis(res3d))
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 test_resid():
# Data is projected onto k=10 dimensional subspace then has its mean
# removed. Should still have rank 10.
k = 10
ncomp = 5
ntotal = k
X = np.random.standard_normal((data['nimages'], k))
p = pca(data['fmridata'], -1, ncomp=ncomp, design_resid=X)
yield assert_equal(
p['basis_vectors'].shape,
(data['nimages'], ntotal))
yield assert_equal(
p['basis_projections'].shape,
data['mask'].shape + (ncomp,))
yield assert_equal(p['pcnt_var'].shape, (ntotal,))
yield assert_almost_equal(p['pcnt_var'].sum(), 100.)
# if design_resid is None, we do not remove the mean, and we get
# full rank from our data
p = pca(data['fmridata'], -1, design_resid=None)
rank = p['basis_vectors'].shape[1]
yield assert_equal(rank, data['nimages'])
rarr = reconstruct(p['basis_vectors'], p['basis_projections'], -1)
# add back the sqrt MSE, because we standardized
rmse = root_mse(data['fmridata'], axis=-1)[...,None]
yield assert_array_almost_equal(rarr * rmse, data['fmridata'])
def test_header_roundtrip():
img = load_image(anatfile)
hdr = img.metadata['header']
# Update some header values and make sure they're saved
hdr['slice_duration'] = 0.200
hdr['intent_p1'] = 2.0
hdr['descrip'] = 'descrip for TestImage:test_header_roundtrip'
hdr['slice_end'] = 12
with InTemporaryDirectory():
save_image(img, 'img.nii.gz')
newimg = load_image('img.nii.gz')
newhdr = newimg.metadata['header']
assert_array_almost_equal(newhdr['slice_duration'], hdr['slice_duration'])
assert_equal(newhdr['intent_p1'], hdr['intent_p1'])
assert_equal(newhdr['descrip'], hdr['descrip'])
assert_equal(newhdr['slice_end'], hdr['slice_end'])
def test_header_roundtrip():
img = load_image(anatfile)
hdr = img.metadata['header']
# Update some header values and make sure they're saved
hdr['slice_duration'] = 0.200
hdr['intent_p1'] = 2.0
hdr['descrip'] = 'descrip for TestImage:test_header_roundtrip'
hdr['slice_end'] = 12
with InTemporaryDirectory():
save_image(img, 'img.nii.gz')
newimg = load_image('img.nii.gz')
newhdr = newimg.metadata['header']
assert_array_almost_equal(newhdr['slice_duration'],
hdr['slice_duration'])
assert_equal(newhdr['intent_p1'], hdr['intent_p1'])
assert_equal(newhdr['descrip'], hdr['descrip'])
assert_equal(newhdr['slice_end'], hdr['slice_end'])
def test_2D():
# check that a standard 2D PCA works too
M = 100
N = 20
L = M-1 # rank after mean removal
data = np.random.uniform(size=(M, N))
p = pca(data)
ts = p['basis_vectors']
imgs = p['basis_projections']
assert_equal(ts.shape, (M, L))
assert_equal(imgs.shape, (L, N))
rimgs = reconstruct(ts, imgs)
# add back the sqrt MSE, because we standardized
data_mean = data.mean(0)[None,...]
demeaned = data - data_mean
rmse = root_mse(demeaned, axis=0)[None,...]
# also add back the mean
assert_array_almost_equal((rimgs * rmse) + data_mean, data)
# if standardize is set, or not, covariance is diagonal
assert_true(diagonal_covariance(imgs))
p = pca(data, standardize=False)
imgs = p['basis_projections']
assert_true(diagonal_covariance(imgs))
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 transformation
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)
with InTemporaryDirectory():
save_image(img, TMP_FNAME)
img2 = load_image(TMP_FNAME)
assert_false(np.allclose(img.affine, img2.affine))
assert_array_almost_equal(img.affine[:3,:3], img2.affine[:3,:3])
assert_equal(img.shape, img2.shape)
assert_array_almost_equal(img2.get_data(), img.get_data())
del img2
