def test_smooth_img():
# This function only checks added functionalities compared
# to _smooth_array()
shapes = ((10, 11, 12), (13, 14, 15))
lengths = (17, 18)
fwhm = (1., 2., 3.)
img1, mask1 = testing.generate_fake_fmri(shape=shapes[0],
length=lengths[0])
img2, mask2 = testing.generate_fake_fmri(shape=shapes[1],
length=lengths[1])
for create_files in (False, True):
with testing.write_tmp_imgs(img1, img2,
create_files=create_files) as imgs:
# List of images as input
out = image.smooth_img(imgs, fwhm)
assert_true(isinstance(out, list))
assert_true(len(out) == 2)
for o, s, l in zip(out, shapes, lengths):
assert_true(o.shape == (s + (l, )))
# Single image as input
out = image.smooth_img(imgs[0], fwhm)
assert_true(isinstance(out, nibabel.Nifti1Image))
assert_true(out.shape == (shapes[0] + (lengths[0], )))
# Check corner case situations when fwhm=0, See issue #1537
# Test whether function smooth_img raises a warning when fwhm=0.
assert_warns(UserWarning, image.smooth_img, img1, fwhm=0.)
# Test output equal when fwhm=None and fwhm=0
out_fwhm_none = image.smooth_img(img1, fwhm=None)
out_fwhm_zero = image.smooth_img(img1, fwhm=0.)
assert_array_equal(out_fwhm_none.get_data(), out_fwhm_zero.get_data())
def test_resampling_nan():
# Test that when the data has NaNs they do not propagate to the
# whole image
for core_shape in [(3, 5, 4), (3, 5, 4, 2)]:
# create deterministic data, padded with one
# voxel thickness of zeros
core_data = np.arange(np.prod(core_shape)).reshape(core_shape).astype(
np.float)
# Introduce a nan
core_data[2, 2:4, 1] = np.nan
full_data_shape = np.array(core_shape) + 2
full_data = np.zeros(full_data_shape)
full_data[[slice(1, 1 + s) for s in core_shape]] = core_data
source_img = Nifti1Image(full_data, np.eye(4))
# Transform real data using easily checkable transformations
# For now: axis permutations
axis_permutation = [0, 1, 2]
# check 3x3 transformation matrix
target_affine = np.eye(3)[axis_permutation]
resampled_img = testing.assert_warns(RuntimeWarning,
resample_img,
source_img,
target_affine=target_affine)
resampled_data = resampled_img.get_data()
if full_data.ndim == 4:
axis_permutation.append(3)
what_resampled_data_should_be = full_data.transpose(axis_permutation)
non_nan = np.isfinite(what_resampled_data_should_be)
# Check that the input data hasn't been modified:
assert_false(np.all(non_nan))
# Check that for finite value resampling works without problems
assert_array_almost_equal(resampled_data[non_nan],
what_resampled_data_should_be[non_nan])
# Check that what was not finite is still not finite
assert_false(
np.any(np.isfinite(resampled_data[np.logical_not(non_nan)])))
# Test with an actual resampling, in the case of a bigish hole
# This checks the extrapolation mechanism: if we don't do any
# extrapolation before resampling, the hole creates big
# artefacts
data = 10 * np.ones((10, 10, 10))
data[4:6, 4:6, 4:6] = np.nan
source_img = Nifti1Image(data, 2 * np.eye(4))
resampled_img = testing.assert_warns(RuntimeWarning,
resample_img,
source_img,
target_affine=np.eye(4))
resampled_data = resampled_img.get_data()
np.testing.assert_allclose(10, resampled_data[np.isfinite(resampled_data)])
def test_resampling_nan():
# Test that when the data has NaNs they do not propagate to the
# whole image
for core_shape in [(3, 5, 4), (3, 5, 4, 2)]:
# create deterministic data, padded with one
# voxel thickness of zeros
core_data = np.arange(np.prod(core_shape)
).reshape(core_shape).astype(np.float)
# Introduce a nan
core_data[2, 2:4, 1] = np.nan
full_data_shape = np.array(core_shape) + 2
full_data = np.zeros(full_data_shape)
full_data[[slice(1, 1 + s) for s in core_shape]] = core_data
source_img = Nifti1Image(full_data, np.eye(4))
# Transform real data using easily checkable transformations
# For now: axis permutations
axis_permutation = [0, 1, 2]
# check 3x3 transformation matrix
target_affine = np.eye(3)[axis_permutation]
resampled_img = testing.assert_warns(
RuntimeWarning, resample_img, source_img,
target_affine=target_affine)
resampled_data = resampled_img.get_data()
if full_data.ndim == 4:
axis_permutation.append(3)
what_resampled_data_should_be = full_data.transpose(axis_permutation)
non_nan = np.isfinite(what_resampled_data_should_be)
# Check that the input data hasn't been modified:
assert_false(np.all(non_nan))
# Check that for finite value resampling works without problems
assert_array_almost_equal(resampled_data[non_nan],
what_resampled_data_should_be[non_nan])
# Check that what was not finite is still not finite
assert_false(np.any(np.isfinite(
resampled_data[np.logical_not(non_nan)])))
# Test with an actual resampling, in the case of a bigish hole
# This checks the extrapolation mechanism: if we don't do any
# extrapolation before resampling, the hole creates big
# artefacts
data = 10 * np.ones((10, 10, 10))
data[4:6, 4:6, 4:6] = np.nan
source_img = Nifti1Image(data, 2 * np.eye(4))
resampled_img = testing.assert_warns(
RuntimeWarning, resample_img, source_img,
target_affine=np.eye(4))
resampled_data = resampled_img.get_data()
np.testing.assert_allclose(10,
resampled_data[np.isfinite(resampled_data)])
def test_screening_space_net():
for verbose in [0, 2]:
screening_percentile = assert_warns(UserWarning,
_adjust_screening_percentile, 10,
mask, verbose)
screening_percentile = assert_warns(UserWarning,
_adjust_screening_percentile, 10, mask)
# We gave here a very small mask, judging by standards of brain size
# thus the screening_percentile_ corrected for brain size should
# be 100%
assert_equal(screening_percentile, 100)
def test_screening_space_net():
for verbose in [0, 2]:
screening_percentile = assert_warns(UserWarning,
_adjust_screening_percentile, 10,
mask, verbose)
screening_percentile = assert_warns(UserWarning,
_adjust_screening_percentile, 10, mask)
# We gave here a very small mask, judging by standards of brain size
# thus the screening_percentile_ corrected for brain size should
# be 100%
assert_equal(screening_percentile, 100)
def test_load_uniform_ball_cloud():
for n_points in [10, 20, 40, 80, 160]:
with warnings.catch_warnings(record=True) as w:
points = surface._load_uniform_ball_cloud(n_points=n_points)
assert_array_equal(points.shape, (n_points, 3))
assert_equal(len(w), 0)
assert_warns(surface.EfficiencyWarning,
surface._load_uniform_ball_cloud, n_points=3)
for n_points in [3, 10, 20]:
computed = surface._uniform_ball_cloud(n_points)
loaded = surface._load_uniform_ball_cloud(n_points)
assert_array_almost_equal(computed, loaded)
def test_move_col_id():
im_terms, col_terms = neurovault._move_col_id(
{
'collection_id': 1,
'not_mni': False
}, {})
assert_equal(im_terms, {'not_mni': False})
assert_equal(col_terms, {'id': 1})
assert_warns(UserWarning, neurovault._move_col_id, {
'collection_id': 1,
'not_mni': False
}, {'id': 2})
def test_load_uniform_ball_cloud():
for n_points in [10, 20, 40, 80, 160]:
with warnings.catch_warnings(record=True) as w:
points = surface._load_uniform_ball_cloud(n_points=n_points)
assert_array_equal(points.shape, (n_points, 3))
assert_equal(len(w), 0)
assert_warns(surface.EfficiencyWarning,
surface._load_uniform_ball_cloud, n_points=3)
# before 0.18 k-means was computed differently, so the result
# would differ from the stored values, computed with version 0.2
if LooseVersion(sklearn.__version__) >= LooseVersion('0.18'):
for n_points in [3, 10, 20]:
computed = surface._uniform_ball_cloud(n_points)
loaded = surface._load_uniform_ball_cloud(n_points)
assert_array_almost_equal(computed, loaded)
def test_load_uniform_ball_cloud():
for n_points in [10, 20, 40, 80, 160]:
with warnings.catch_warnings(record=True) as w:
points = surface._load_uniform_ball_cloud(n_points=n_points)
assert_array_equal(points.shape, (n_points, 3))
assert_equal(len(w), 0)
assert_warns(surface.EfficiencyWarning,
surface._load_uniform_ball_cloud,
n_points=3)
# before 0.18 k-means was computed differently, so the result
# would differ from the stored values, computed with version 0.2
if LooseVersion(sklearn.__version__) >= LooseVersion('0.18'):
for n_points in [3, 10, 20]:
computed = surface._uniform_ball_cloud(n_points)
loaded = surface._load_uniform_ball_cloud(n_points)
assert_array_almost_equal(computed, loaded)
def test_find_cut_coords():
data = np.zeros((100, 100, 100))
x_map, y_map, z_map = 50, 10, 40
data[x_map - 30:x_map + 30, y_map - 3:y_map + 3, z_map - 10:z_map + 10] = 1
# identity affine
affine = np.eye(4)
img = nibabel.Nifti1Image(data, affine)
mask_img = compute_epi_mask(img)
x, y, z = find_xyz_cut_coords(img,
mask_img=mask_img)
np.testing.assert_allclose((x, y, z),
(x_map, y_map, z_map),
# Need such a high tolerance for the test to
# pass. x, y, z = [49.5, 9.5, 39.5]
rtol=6e-2)
# non-trivial affine
affine = np.diag([1. / 2, 1 / 3., 1 / 4., 1.])
img = nibabel.Nifti1Image(data, affine)
mask_img = compute_epi_mask(img)
x, y, z = find_xyz_cut_coords(img, mask_img=mask_img)
np.testing.assert_allclose((x, y, z),
(x_map / 2., y_map / 3., z_map / 4.),
# Need such a high tolerance for the test to
# pass. x, y, z = [24.75, 3.17, 9.875]
rtol=6e-2)
# regression test (cf. #473)
# test case: no data exceeds the activation threshold
data = np.ones((36, 43, 36))
affine = np.eye(4)
img = nibabel.Nifti1Image(data, affine)
x, y, z = find_xyz_cut_coords(img, activation_threshold=1.1)
np.testing.assert_array_equal(
np.array([x, y, z]),
0.5 * np.array(data.shape).astype(np.float))
# regression test (cf. #922)
# pseudo-4D images as input (i.e., X, Y, Z, 1)
# previously raised "ValueError: too many values to unpack"
rng = np.random.RandomState(42)
data_3d = rng.randn(10, 10, 10)
data_4d = data_3d[..., np.newaxis]
affine = np.eye(4)
img_3d = nibabel.Nifti1Image(data_3d, affine)
img_4d = nibabel.Nifti1Image(data_4d, affine)
assert_equal(find_xyz_cut_coords(img_3d), find_xyz_cut_coords(img_4d))
# test passing empty image returns coordinates pointing to AC-PC line
data = np.zeros((20, 30, 40))
affine = np.eye(4)
img = nibabel.Nifti1Image(data, affine)
cut_coords = find_xyz_cut_coords(img)
assert_equal(cut_coords, [0.0, 0.0, 0.0])
cut_coords = assert_warns(UserWarning, find_xyz_cut_coords, img)
def test_check_threshold():
matrix = np.array([[1., 2.], [2., 1.]])
name = 'threshold'
# few not correctly formatted strings for 'threshold'
wrong_thresholds = ['0.1', '10', '10.2.3%', 'asdf%']
for wrong_threshold in wrong_thresholds:
assert_raises_regex(
ValueError, '{0}.+should be a number followed by '
'the percent sign'.format(name), check_threshold, wrong_threshold,
matrix, 'fast_abs_percentile', name)
threshold = object()
assert_raises_regex(
TypeError, '{0}.+should be either a number '
'or a string'.format(name), check_threshold, threshold, matrix,
'fast_abs_percentile', name)
# Test threshold as int, threshold=2 should return as it is
# since it is not string
assert_equal(
check_threshold(2, matrix, percentile_func=fast_abs_percentile), 2)
# check whether raises a warning if given threshold is higher than expected
assert_warns(UserWarning,
check_threshold,
3.,
matrix,
percentile_func=fast_abs_percentile)
# test with numpy scalar as argument
threshold = 2.
threshold_numpy_scalar = np.float64(threshold)
assert_equal(
check_threshold(threshold, matrix,
percentile_func=fast_abs_percentile),
check_threshold(threshold_numpy_scalar,
matrix,
percentile_func=fast_abs_percentile))
# Test for threshold provided as a percentile of the data (str ending with a
# %)
assert_true(1. < check_threshold(
"50%", matrix, percentile_func=fast_abs_percentile, name=name) <= 2.)
def test_check_embedded_nifti_masker():
owner = OwningClass()
masker = check_embedded_nifti_masker(owner)
assert_true(type(masker) is MultiNiftiMasker)
for mask, multi_subject in ((MultiNiftiMasker(), True), (NiftiMasker(),
False)):
owner = OwningClass(mask=mask)
masker = check_embedded_nifti_masker(owner,
multi_subject=multi_subject)
assert_equal(type(masker), type(mask))
for param_key in masker.get_params():
if param_key not in [
'memory', 'memory_level', 'n_jobs', 'verbose'
]:
assert_equal(getattr(masker, param_key),
getattr(mask, param_key))
else:
assert_equal(getattr(masker, param_key),
getattr(owner, param_key))
# Check use of mask as mask_img
shape = (6, 8, 10, 5)
affine = np.eye(4)
mask = nibabel.Nifti1Image(np.ones(shape[:3], dtype=np.int8), affine)
owner = OwningClass(mask=mask)
masker = check_embedded_nifti_masker(owner)
assert_true(masker.mask_img is mask)
# Check attribute forwarding
data = np.zeros((9, 9, 9))
data[2:-2, 2:-2, 2:-2] = 10
imgs = nibabel.Nifti1Image(data, np.eye(4))
mask = MultiNiftiMasker()
mask.fit([[imgs]])
owner = OwningClass(mask=mask)
masker = check_embedded_nifti_masker(owner)
assert_true(masker.mask_img is mask.mask_img_)
# Check conflict warning
mask = NiftiMasker(mask_strategy='epi')
owner = OwningClass(mask=mask)
assert_warns(UserWarning, check_embedded_nifti_masker, owner)
def test_smooth_img():
# This function only checks added functionalities compared
# to _smooth_array()
shapes = ((10, 11, 12), (13, 14, 15))
lengths = (17, 18)
fwhm = (1., 2., 3.)
img1, mask1 = data_gen.generate_fake_fmri(shape=shapes[0],
length=lengths[0])
img2, mask2 = data_gen.generate_fake_fmri(shape=shapes[1],
length=lengths[1])
for create_files in (False, True):
with testing.write_tmp_imgs(img1, img2,
create_files=create_files) as imgs:
# List of images as input
out = image.smooth_img(imgs, fwhm)
assert_true(isinstance(out, list))
assert_true(len(out) == 2)
for o, s, l in zip(out, shapes, lengths):
assert_true(o.shape == (s + (l,)))
# Single image as input
out = image.smooth_img(imgs[0], fwhm)
assert_true(isinstance(out, nibabel.Nifti1Image))
assert_true(out.shape == (shapes[0] + (lengths[0],)))
# Check corner case situations when fwhm=0, See issue #1537
# Test whether function smooth_img raises a warning when fwhm=0.
assert_warns(UserWarning, image.smooth_img, img1, fwhm=0.)
# Test output equal when fwhm=None and fwhm=0
out_fwhm_none = image.smooth_img(img1, fwhm=None)
out_fwhm_zero = image.smooth_img(img1, fwhm=0.)
assert_array_equal(out_fwhm_none.get_data(), out_fwhm_zero.get_data())
data1 = np.zeros((10, 11, 12))
data1[2:4, 1:5, 3:6] = 1
data2 = np.zeros((13, 14, 15))
data2[2:4, 1:5, 3:6] = 9
img1_nifti2 = nibabel.Nifti2Image(data1, affine=np.eye(4))
img2_nifti2 = nibabel.Nifti2Image(data2, affine=np.eye(4))
out = image.smooth_img([img1_nifti2, img2_nifti2], fwhm=1.)
def test_load_uniform_ball_cloud():
# Note: computed and shipped point clouds may differ since KMeans results
# change after
# https://github.com/scikit-learn/scikit-learn/pull/9288
# but the exact position of the points does not matter as long as they are
# well spread inside the unit ball
for n_points in [10, 20, 40, 80, 160]:
with warnings.catch_warnings(record=True) as w:
points = surface._load_uniform_ball_cloud(n_points=n_points)
assert_array_equal(points.shape, (n_points, 3))
assert_equal(len(w), 0)
assert_warns(surface.EfficiencyWarning,
surface._load_uniform_ball_cloud, n_points=3)
for n_points in [3, 7]:
computed = surface._uniform_ball_cloud(n_points)
loaded = surface._load_uniform_ball_cloud(n_points)
assert_array_almost_equal(computed, loaded)
assert (np.std(computed, axis=0) > .1).all()
assert (np.linalg.norm(computed, axis=1) <= 1).all()
def test_check_threshold():
matrix = np.array([[1., 2.],
[2., 1.]])
name = 'threshold'
# few not correctly formatted strings for 'threshold'
wrong_thresholds = ['0.1', '10', '10.2.3%', 'asdf%']
for wrong_threshold in wrong_thresholds:
assert_raises_regex(ValueError,
'{0}.+should be a number followed by '
'the percent sign'.format(name),
check_threshold,
wrong_threshold, matrix,
'fast_abs_percentile', name)
threshold = object()
assert_raises_regex(TypeError,
'{0}.+should be either a number '
'or a string'.format(name),
check_threshold, threshold, matrix,
'fast_abs_percentile', name)
# Test threshold as int, threshold=2 should return as it is
# since it is not string
assert_equal(check_threshold(2, matrix, percentile_func=fast_abs_percentile), 2)
# check whether raises a warning if given threshold is higher than expected
assert_warns(UserWarning, check_threshold, 3., matrix,
percentile_func=fast_abs_percentile)
# test with numpy scalar as argument
threshold = 2.
threshold_numpy_scalar = np.float64(threshold)
assert_equal(
check_threshold(threshold, matrix, percentile_func=fast_abs_percentile),
check_threshold(threshold_numpy_scalar, matrix,
percentile_func=fast_abs_percentile))
# Test for threshold provided as a percentile of the data (str ending with a
# %)
assert_true(1. < check_threshold("50%", matrix,
percentile_func=fast_abs_percentile,
name=name) <= 2.)
def test_check_embedded_nifti_masker():
owner = OwningClass()
masker = check_embedded_nifti_masker(owner)
assert_true(type(masker) is MultiNiftiMasker)
for mask, multi_subject in (
(MultiNiftiMasker(), True), (NiftiMasker(), False)):
owner = OwningClass(mask=mask)
masker = check_embedded_nifti_masker(owner,
multi_subject=multi_subject)
assert_equal(type(masker), type(mask))
for param_key in masker.get_params():
if param_key not in ['memory', 'memory_level', 'n_jobs',
'verbose']:
assert_equal(getattr(masker, param_key),
getattr(mask, param_key))
else:
assert_equal(getattr(masker, param_key),
getattr(owner, param_key))
# Check use of mask as mask_img
shape = (6, 8, 10, 5)
affine = np.eye(4)
mask = nibabel.Nifti1Image(np.ones(shape[:3], dtype=np.int8), affine)
owner = OwningClass(mask=mask)
masker = check_embedded_nifti_masker(owner)
assert_true(masker.mask_img is mask)
# Check attribute forwarding
data = np.zeros((9, 9, 9))
data[2:-2, 2:-2, 2:-2] = 10
imgs = nibabel.Nifti1Image(data, np.eye(4))
mask = MultiNiftiMasker()
mask.fit([[imgs]])
owner = OwningClass(mask=mask)
masker = check_embedded_nifti_masker(owner)
assert_true(masker.mask_img is mask.mask_img_)
# Check conflict warning
mask = NiftiMasker(mask_strategy='epi')
owner = OwningClass(mask=mask)
assert_warns(UserWarning, check_embedded_nifti_masker, owner)
def test_compute_gray_matter_mask():
image = Nifti1Image(np.ones((9, 9, 9)), np.eye(4))
mask = compute_gray_matter_mask(image, threshold=-1)
mask1 = np.zeros((9, 9, 9))
mask1[2:-2, 2:-2, 2:-2] = 1
np.testing.assert_array_equal(mask1, mask.get_data())
# Check that we get a useful warning for empty masks
assert_warns(masking.MaskWarning, compute_gray_matter_mask, image, threshold=1)
# Check that masks obtained from same FOV are the same
img1 = Nifti1Image(np.full((9, 9, 9), np.random.rand()), np.eye(4))
img2 = Nifti1Image(np.full((9, 9, 9), np.random.rand()), np.eye(4))
mask_img1 = compute_gray_matter_mask(img1)
mask_img2 = compute_gray_matter_mask(img2)
np.testing.assert_array_equal(mask_img1.get_data(),
mask_img2.get_data())
def test_fetch_neurovault():
with _TestTemporaryDirectory() as temp_dir:
# check that nothing is downloaded in offline mode
data = neurovault.fetch_neurovault(mode='offline', data_dir=temp_dir)
assert_equal(len(data.images), 0)
# try to download an image
data = neurovault.fetch_neurovault(max_images=1,
fetch_neurosynth_words=True,
mode='overwrite',
data_dir=temp_dir)
# specifying a filter while leaving the default term
# filters in place should raise a warning.
assert_warns(UserWarning,
neurovault.fetch_neurovault,
image_filter=lambda x: True,
max_images=1,
mode='offline')
# if neurovault was available one image matching
# default filters should have been downloaded
if data.images:
assert_equal(len(data.images), 1)
meta = data.images_meta[0]
assert_false(meta['not_mni'])
assert_true(meta['is_valid'])
assert_false(meta['not_mni'])
assert_false(meta['is_thresholded'])
assert_false(
meta['map_type'] in ['ROI/mask', 'anatomical', 'parcellation'])
assert_false(meta['image_type'] == 'atlas')
# using a data directory we can't write into should raise a
# warning unless mode is 'offline'
os.chmod(temp_dir, stat.S_IREAD | stat.S_IEXEC)
os.chmod(os.path.join(temp_dir, 'neurovault'),
stat.S_IREAD | stat.S_IEXEC)
if os.access(os.path.join(temp_dir, 'neurovault'), os.W_OK):
return
assert_warns(UserWarning,
neurovault.fetch_neurovault,
data_dir=temp_dir)
def test_compute_gray_matter_mask():
image = Nifti1Image(np.ones((9, 9, 9)), np.eye(4))
mask = compute_gray_matter_mask(image, threshold=-1)
mask1 = np.zeros((9, 9, 9))
mask1[2:-2, 2:-2, 2:-2] = 1
np.testing.assert_array_equal(mask1, get_data(mask))
# Check that we get a useful warning for empty masks
assert_warns(masking.MaskWarning,
compute_gray_matter_mask,
image,
threshold=1)
# Check that masks obtained from same FOV are the same
img1 = Nifti1Image(np.full((9, 9, 9), np.random.rand()), np.eye(4))
img2 = Nifti1Image(np.full((9, 9, 9), np.random.rand()), np.eye(4))
mask_img1 = compute_gray_matter_mask(img1)
mask_img2 = compute_gray_matter_mask(img2)
np.testing.assert_array_equal(get_data(mask_img1), get_data(mask_img2))
def test_neurosynth_words_vectorized():
n_im = 5
with _TestTemporaryDirectory() as temp_dir:
words_files = [
os.path.join(temp_dir, 'words_for_image_{0}.json'.format(i))
for i in range(n_im)
]
words = [str(i) for i in range(n_im)]
for i, file_name in enumerate(words_files):
word_weights = np.zeros(n_im)
word_weights[i] = 1
words_dict = {
'data': {
'values':
dict([(k, v) for k, v in zip(words, word_weights)])
}
}
with open(file_name, 'wb') as words_file:
words_file.write(json.dumps(words_dict).encode('utf-8'))
freq, voc = neurovault.neurosynth_words_vectorized(words_files)
assert_equal(freq.shape, (n_im, n_im))
assert ((freq.sum(axis=0) == np.ones(n_im)).all())
assert_warns(UserWarning, neurovault.neurosynth_words_vectorized,
(os.path.join(temp_dir, 'no_words_here.json'), ))
def test_find_cuts_empty_mask_no_crash():
img = nibabel.Nifti1Image(np.ones((2, 2, 2)), np.eye(4))
mask = np.zeros((2, 2, 2)).astype(np.bool)
cut_coords = assert_warns(UserWarning, find_xyz_cut_coords, img, mask=mask)
np.testing.assert_array_equal(cut_coords, [.5, .5, .5])
def test_find_cuts_empty_mask_no_crash():
img = nibabel.Nifti1Image(np.ones((2, 2, 2)), np.eye(4))
mask_img = compute_epi_mask(img)
cut_coords = assert_warns(UserWarning, find_xyz_cut_coords, img,
mask_img=mask_img)
np.testing.assert_array_equal(cut_coords, [.5, .5, .5])
def test__smooth_array():
"""Test smoothing of images: _smooth_array()"""
# Impulse in 3D
data = np.zeros((40, 41, 42))
data[20, 20, 20] = 1
# fwhm divided by any test affine must be odd. Otherwise assertion below
# will fail. ( 9 / 0.6 = 15 is fine)
fwhm = 9
test_affines = (np.eye(4), np.diag((1, 1, -1, 1)), np.diag((.6, 1, .6, 1)))
for affine in test_affines:
filtered = image._smooth_array(data, affine, fwhm=fwhm, copy=True)
assert_false(np.may_share_memory(filtered, data))
# We are expecting a full-width at half maximum of
# fwhm / voxel_size:
vmax = filtered.max()
above_half_max = filtered > .5 * vmax
for axis in (0, 1, 2):
proj = np.any(np.any(np.rollaxis(above_half_max, axis=axis),
axis=-1),
axis=-1)
np.testing.assert_equal(proj.sum(),
fwhm / np.abs(affine[axis, axis]))
# Check that NaNs in the data do not propagate
data[10, 10, 10] = np.NaN
filtered = image._smooth_array(data,
affine,
fwhm=fwhm,
ensure_finite=True,
copy=True)
assert_true(np.all(np.isfinite(filtered)))
# Check copy=False.
for affine in test_affines:
data = np.zeros((40, 41, 42))
data[20, 20, 20] = 1
image._smooth_array(data, affine, fwhm=fwhm, copy=False)
# We are expecting a full-width at half maximum of
# fwhm / voxel_size:
vmax = data.max()
above_half_max = data > .5 * vmax
for axis in (0, 1, 2):
proj = np.any(np.any(np.rollaxis(above_half_max, axis=axis),
axis=-1),
axis=-1)
np.testing.assert_equal(proj.sum(),
fwhm / np.abs(affine[axis, axis]))
# Check fwhm='fast'
for affine in test_affines:
np.testing.assert_equal(image._smooth_array(data, affine, fwhm='fast'),
image._fast_smooth_array(data))
# Check corner case when fwhm=0. See #1537
# Test whether function _smooth_array raises a warning when fwhm=0.
assert_warns(UserWarning, image._smooth_array, data, affine, fwhm=0.)
# Test output equal when fwhm=None and fwhm=0
out_fwhm_none = image._smooth_array(data, affine, fwhm=None)
out_fwhm_zero = image._smooth_array(data, affine, fwhm=0.)
assert_array_equal(out_fwhm_none, out_fwhm_zero)
def test_find_cuts_empty_mask_no_crash():
img = nibabel.Nifti1Image(np.ones((2, 2, 2)), np.eye(4))
mask = np.zeros((2, 2, 2)).astype(np.bool)
cut_coords = assert_warns(UserWarning, find_xyz_cut_coords, img,
mask=mask)
np.testing.assert_array_equal(cut_coords, [.5, .5, .5])
def test__smooth_array():
"""Test smoothing of images: _smooth_array()"""
# Impulse in 3D
data = np.zeros((40, 41, 42))
data[20, 20, 20] = 1
# fwhm divided by any test affine must be odd. Otherwise assertion below
# will fail. ( 9 / 0.6 = 15 is fine)
fwhm = 9
test_affines = (np.eye(4), np.diag((1, 1, -1, 1)),
np.diag((.6, 1, .6, 1)))
for affine in test_affines:
filtered = image._smooth_array(data, affine,
fwhm=fwhm, copy=True)
assert_false(np.may_share_memory(filtered, data))
# We are expecting a full-width at half maximum of
# fwhm / voxel_size:
vmax = filtered.max()
above_half_max = filtered > .5 * vmax
for axis in (0, 1, 2):
proj = np.any(np.any(np.rollaxis(above_half_max,
axis=axis), axis=-1), axis=-1)
np.testing.assert_equal(proj.sum(),
fwhm / np.abs(affine[axis, axis]))
# Check that NaNs in the data do not propagate
data[10, 10, 10] = np.NaN
filtered = image._smooth_array(data, affine, fwhm=fwhm,
ensure_finite=True, copy=True)
assert_true(np.all(np.isfinite(filtered)))
# Check copy=False.
for affine in test_affines:
data = np.zeros((40, 41, 42))
data[20, 20, 20] = 1
image._smooth_array(data, affine, fwhm=fwhm, copy=False)
# We are expecting a full-width at half maximum of
# fwhm / voxel_size:
vmax = data.max()
above_half_max = data > .5 * vmax
for axis in (0, 1, 2):
proj = np.any(np.any(np.rollaxis(above_half_max,
axis=axis), axis=-1), axis=-1)
np.testing.assert_equal(proj.sum(),
fwhm / np.abs(affine[axis, axis]))
# Check fwhm='fast'
for affine in test_affines:
np.testing.assert_equal(image._smooth_array(data, affine, fwhm='fast'),
image._fast_smooth_array(data))
# Check corner case when fwhm=0. See #1537
# Test whether function _smooth_array raises a warning when fwhm=0.
assert_warns(UserWarning, image._smooth_array, data, affine, fwhm=0.)
# Test output equal when fwhm=None and fwhm=0
out_fwhm_none = image._smooth_array(data, affine, fwhm=None)
out_fwhm_zero = image._smooth_array(data, affine, fwhm=0.)
assert_array_equal(out_fwhm_none, out_fwhm_zero)
