def test_nifti_labels_masker_with_nans_and_infs_in_data():
"""Apply a NiftiLabelsMasker to 4D data containing NaNs and infs.
The masker should replace those NaNs and infs with zeros,
while raising a warning.
"""
length = 3
n_regions = 9
fmri_img, mask_img = generate_random_img((13, 11, 12),
affine=np.eye(4),
length=length)
labels_img = data_gen.generate_labeled_regions((13, 11, 12),
affine=np.eye(4),
n_regions=n_regions)
# Introduce nans with data type float
# See issues:
# - https://github.com/nilearn/nilearn/issues/2580 (why floats)
# - https://github.com/nilearn/nilearn/issues/2711 (why test)
fmri_data = get_data(fmri_img).astype(np.float32)
fmri_data[:, :, 7, :] = np.nan
fmri_data[:, :, 4, 0] = np.inf
fmri_img = nibabel.Nifti1Image(fmri_data, np.eye(4))
masker = NiftiLabelsMasker(labels_img, mask_img=mask_img)
with pytest.warns(UserWarning, match="Non-finite values detected."):
sig = masker.fit_transform(fmri_img)
assert sig.shape == (length, n_regions)
assert np.all(np.isfinite(sig))
def test_standardization():
rng = np.random.RandomState(42)
data_shape = (9, 9, 5)
n_samples = 500
signals = rng.standard_normal(size=(np.prod(data_shape), n_samples))
means = rng.standard_normal(size=(np.prod(data_shape), 1)) * 50 + 1000
signals += means
img = nibabel.Nifti1Image(signals.reshape(data_shape + (n_samples, )),
np.eye(4))
labels = data_gen.generate_labeled_regions((9, 9, 5), 10)
# Unstandarized
masker = NiftiLabelsMasker(labels, standardize=False)
unstandarized_label_signals = masker.fit_transform(img)
# z-score
masker = NiftiLabelsMasker(labels, standardize='zscore')
trans_signals = masker.fit_transform(img)
np.testing.assert_almost_equal(trans_signals.mean(0), 0)
np.testing.assert_almost_equal(trans_signals.std(0), 1)
# psc
masker = NiftiLabelsMasker(labels, standardize='psc')
trans_signals = masker.fit_transform(img)
np.testing.assert_almost_equal(trans_signals.mean(0), 0)
np.testing.assert_almost_equal(
trans_signals, (unstandarized_label_signals /
unstandarized_label_signals.mean(0) * 100 - 100))
def test_generate_labeled_regions():
"""Minimal testing of generate_labeled_regions"""
shape = (3, 4, 5)
n_regions = 10
regions = generate_labeled_regions(shape, n_regions)
assert_true(regions.shape == shape)
assert (len(np.unique(get_data(regions))) == n_regions + 1)
def test_generate_labeled_regions():
"""Minimal testing of generate_labeled_regions"""
shape = (3, 4, 5)
n_regions = 10
regions = generate_labeled_regions(shape, n_regions)
assert_true(regions.shape == shape)
assert (len(np.unique(regions.get_data())) == n_regions + 1)
def _schaefer_img(match, request):
info = match.groupdict()
shape = (15, 14, 13)
affine = np.eye(4) * float(info["res"])
affine[3, 3] = 1.
img = data_gen.generate_labeled_regions(
shape, int(info["n_rois"]), affine=affine)
return serialize_niimg(img)
def test_error_messages_connected_label_regions():
shape = (13, 11, 12)
affine = np.eye(4)
n_regions = 2
labels_img = generate_labeled_regions(shape, affine=affine,
n_regions=n_regions)
assert_raises_regex(ValueError,
"Expected 'min_size' to be specified as integer.",
connected_label_regions,
labels_img=labels_img, min_size='a')
assert_raises_regex(ValueError,
"'connect_diag' must be specified as True or False.",
connected_label_regions,
labels_img=labels_img, connect_diag=None)
def test_error_messages_connected_label_regions():
shape = (13, 11, 12)
affine = np.eye(4)
n_regions = 2
labels_img = generate_labeled_regions(shape, affine=affine,
n_regions=n_regions)
with pytest.raises(
ValueError,
match="Expected 'min_size' to be specified as integer."):
connected_label_regions(labels_img=labels_img, min_size='a')
with pytest.raises(
ValueError,
match="'connect_diag' must be specified as True or False."):
connected_label_regions(labels_img=labels_img, connect_diag=None)
def test_nifti_labels_masker_with_mask():
shape = (13, 11, 12)
affine = np.eye(4)
fmri_img, mask_img = generate_random_img(shape, affine=affine, length=3)
labels_img = data_gen.generate_labeled_regions(shape, affine=affine,
n_regions=7)
masker = NiftiLabelsMasker(
labels_img, resampling_target=None, mask_img=mask_img)
signals = masker.fit().transform(fmri_img)
bg_masker = NiftiMasker(mask_img).fit()
masked_labels = bg_masker.inverse_transform(bg_masker.transform(labels_img))
masked_masker = NiftiLabelsMasker(
masked_labels, resampling_target=None, mask_img=mask_img)
masked_signals = masked_masker.fit().transform(fmri_img)
assert np.allclose(signals, masked_signals)
def input_parameters(masker_class, data_img_3d):
n_regions = 9
shape = (13, 11, 12)
affine = np.diag([2, 2, 2, 1])
labels = ["background"]
labels += [f"region_{i}" for i in range(1, n_regions + 1)]
if masker_class == NiftiMasker:
return {"mask_img": data_img_3d}
if masker_class == NiftiLabelsMasker:
labels_img = generate_labeled_regions(shape,
n_regions=n_regions,
affine=affine)
return {"labels_img": labels_img, "labels": labels}
elif masker_class == NiftiMapsMasker:
label_img, _ = generate_maps(shape, n_regions=n_regions, affine=affine)
return {"maps_img": label_img}
def test_3d_images():
# Test that the NiftiLabelsMasker works with 3D images
affine = np.eye(4)
n_regions = 3
shape3 = (2, 2, 2)
labels33_img = data_gen.generate_labeled_regions(shape3, n_regions)
mask_img = nibabel.Nifti1Image(np.ones(shape3, dtype=np.int8),
affine=affine)
epi_img1 = nibabel.Nifti1Image(np.ones(shape3), affine=affine)
epi_img2 = nibabel.Nifti1Image(np.ones(shape3), affine=affine)
masker = NiftiLabelsMasker(labels33_img, mask_img=mask_img)
epis = masker.fit_transform(epi_img1)
assert (epis.shape == (1, 3))
epis = masker.fit_transform([epi_img1, epi_img2])
assert (epis.shape == (2, 3))
def test_nifti_labels_masker_with_nans_and_infs():
length = 3
n_regions = 9
fmri_img, mask_img = generate_random_img((13, 11, 12),
affine=np.eye(4), length=length)
labels_img = data_gen.generate_labeled_regions((13, 11, 12),
affine=np.eye(4),
n_regions=n_regions)
# nans
mask_data = get_data(mask_img)
mask_data[:, :, 7] = np.nan
mask_data[:, :, 4] = np.inf
mask_img = nibabel.Nifti1Image(mask_data, np.eye(4))
masker = NiftiLabelsMasker(labels_img, mask_img=mask_img)
sig = masker.fit_transform(fmri_img)
assert sig.shape == (length, n_regions)
assert np.all(np.isfinite(sig))
def test_nifti_labels_masker_with_nans_and_infs():
length = 3
n_regions = 9
fmri_img, mask_img = generate_random_img((13, 11, 12),
affine=np.eye(4), length=length)
labels_img = data_gen.generate_labeled_regions((13, 11, 12),
affine=np.eye(4),
n_regions=n_regions)
# nans
mask_data = mask_img.get_data()
mask_data[:, :, 7] = np.nan
mask_data[:, :, 4] = np.inf
mask_img = nibabel.Nifti1Image(mask_data, np.eye(4))
masker = NiftiLabelsMasker(labels_img, mask_img=mask_img)
sig = masker.fit_transform(fmri_img)
assert_equal(sig.shape, (length, n_regions))
assert_true(np.all(np.isfinite(sig)))
def test_nifti_labels_masker_with_nans_and_infs():
length = 3
n_regions = 9
fmri_img, mask_img = generate_random_img((13, 11, 12),
affine=np.eye(4),
length=length)
labels_img = data_gen.generate_labeled_regions((13, 11, 12),
affine=np.eye(4),
n_regions=n_regions)
# Introduce nans with data type float
# See issue: https://github.com/nilearn/nilearn/issues/2580
mask_data = get_data(mask_img).astype(np.float32)
mask_data[:, :, 7] = np.nan
mask_data[:, :, 4] = np.inf
mask_img = nibabel.Nifti1Image(mask_data, np.eye(4))
masker = NiftiLabelsMasker(labels_img, mask_img=mask_img)
sig = masker.fit_transform(fmri_img)
assert sig.shape == (length, n_regions)
assert np.all(np.isfinite(sig))
def test_fetch_atlas_pauli_2017(tmp_path, request_mocker):
labels = pd.DataFrame({
"label": list(map("label_{}".format, range(16)))
}).to_csv(sep="\t", header=False)
det_atlas = data_gen.generate_labeled_regions((7, 6, 5), 16)
prob_atlas, _ = data_gen.generate_maps((7, 6, 5), 16)
request_mocker.url_mapping["*osf.io/6qrcb/*"] = labels
request_mocker.url_mapping["*osf.io/5mqfx/*"] = det_atlas
request_mocker.url_mapping["*osf.io/w8zq2/*"] = prob_atlas
data_dir = str(tmp_path / 'pauli_2017')
data = atlas.fetch_atlas_pauli_2017('det', data_dir)
assert len(data.labels) == 16
values = get_data(nibabel.load(data.maps))
assert len(np.unique(values)) == 17
data = atlas.fetch_atlas_pauli_2017('prob', data_dir)
assert nibabel.load(data.maps).shape[-1] == 16
with pytest.raises(NotImplementedError):
atlas.fetch_atlas_pauli_2017('junk for testing', data_dir)
def test_largest_cc():
""" Check the extraction of the largest connected component.
"""
a = np.zeros((6, 6, 6))
pytest.raises(ValueError, largest_connected_component, a)
a[1:3, 1:3, 1:3] = 1
np.testing.assert_equal(a, largest_connected_component(a))
# A simple test with non-native dtype
a_change_type = a.astype('>f8')
np.testing.assert_equal(a, largest_connected_component(a_change_type))
b = a.copy()
b[5, 5, 5] = 1
np.testing.assert_equal(a, largest_connected_component(b))
# A simple test with non-native dtype
b_change_type = b.astype('>f8')
np.testing.assert_equal(a, largest_connected_component(b_change_type))
# Tests for correct errors, when an image or string are passed.
img = data_gen.generate_labeled_regions(shape=(10, 11, 12), n_regions=2)
pytest.raises(ValueError, largest_connected_component, img)
pytest.raises(ValueError, largest_connected_component, "Test String")
def test_empty_report():
# Data for NiftiMasker
data = np.zeros((9, 9, 9))
data[3:-3, 3:-3, 3:-3] = 10
data_img_3d = Nifti1Image(data, np.eye(4))
# Data for NiftiLabelsMasker
shape = (13, 11, 12)
affine = np.diag([2, 2, 2, 1])
n_regions = 9
labels_img = data_gen.generate_labeled_regions(shape,
affine=affine,
n_regions=n_regions)
# turn off reporting
maskers = [input_data.NiftiMasker(reports=False),
input_data.NiftiLabelsMasker(labels_img, reports=False)]
for masker in maskers:
masker.fit(data_img_3d)
assert masker._reporting_data is None
assert masker._reporting() == [None]
with pytest.warns(UserWarning,
match=("Report generation not enabled ! "
"No visual outputs will be created.")):
masker.generate_report()
def parcellation_data():
"""Fixture for parcellations."""
parcels_tmp = tempfile.NamedTemporaryFile(mode='w+', suffix='.nii.gz')
labels = pd.DataFrame({"label":
list(map("label_{}".format,
range(16)))})['label'].values.tolist()
parcellation = data_gen.generate_labeled_regions((7, 6, 5), 16)
parcels = parcellation.get_fdata()
net_parcels_map_nifti_file = str(parcels_tmp.name)
parcellation.to_filename(net_parcels_map_nifti_file)
[coords, indices] = find_parcellation_cut_coords(parcellation,
0,
return_label_names=True)
coords = list(tuple(x) for x in coords)
yield {
'net_parcels_map_nifti_file': net_parcels_map_nifti_file,
'parcels': parcels,
'labels': labels,
'coords': coords,
'indices': indices
}
parcels_tmp.close()
def test_largest_cc():
""" Check the extraction of the largest connected component.
"""
a = np.zeros((6, 6, 6))
assert_raises(ValueError, largest_connected_component, a)
a[1:3, 1:3, 1:3] = 1
np.testing.assert_equal(a, largest_connected_component(a))
# A simple test with non-native dtype
a_change_type = a.astype('>f8')
np.testing.assert_equal(a, largest_connected_component(a_change_type))
b = a.copy()
b[5, 5, 5] = 1
np.testing.assert_equal(a, largest_connected_component(b))
# A simple test with non-native dtype
b_change_type = b.astype('>f8')
np.testing.assert_equal(a, largest_connected_component(b_change_type))
# Tests for correct errors, when an image or string are passed.
img = data_gen.generate_labeled_regions(shape=(10, 11, 12),
n_regions=2)
assert_raises(ValueError, largest_connected_component, img)
assert_raises(ValueError, largest_connected_component, "Test String")
def test_largest_cc_img():
""" Check the extraction of the largest connected component, for niftis
Similar to smooth_img tests for largest connected_component_img, here also
only the added features for largest_connected_component are tested.
"""
# Test whether dimension of 3Dimg and list of 3Dimgs are kept.
shapes = ((10, 11, 12), (13, 14, 15))
regions = [1, 3]
img1 = data_gen.generate_labeled_regions(shape=shapes[0],
n_regions=regions[0])
img2 = data_gen.generate_labeled_regions(shape=shapes[1],
n_regions=regions[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 = largest_connected_component_img(imgs)
assert isinstance(out, list)
assert len(out) == 2
for o, s in zip(out, shapes):
assert o.shape == (s)
# Single image as input
out = largest_connected_component_img(imgs[0])
assert isinstance(out, Nifti1Image)
assert out.shape == (shapes[0])
# Test whether 4D Nifti throws the right error.
img_4D = data_gen.generate_fake_fmri(shapes[0], length=17)
pytest.raises(DimensionError, largest_connected_component_img, img_4D)
# tests adapted to non-native endian data dtype
img1_change_dtype = nibabel.Nifti1Image(get_data(img1).astype('>f8'),
affine=img1.affine)
img2_change_dtype = nibabel.Nifti1Image(get_data(img2).astype('>f8'),
affine=img2.affine)
for create_files in (False, True):
with testing.write_tmp_imgs(img1_change_dtype,
img2_change_dtype,
create_files=create_files) as imgs:
# List of images as input
out = largest_connected_component_img(imgs)
assert isinstance(out, list)
assert len(out) == 2
for o, s in zip(out, shapes):
assert o.shape == (s)
# Single image as input
out = largest_connected_component_img(imgs[0])
assert isinstance(out, Nifti1Image)
assert out.shape == (shapes[0])
# Test the output with native and without native
out_native = largest_connected_component_img(img1)
out_non_native = largest_connected_component_img(img1_change_dtype)
np.testing.assert_equal(get_data(out_native), get_data(out_non_native))
def test_signal_extraction_with_maps_and_labels():
shape = (4, 5, 6)
n_regions = 7
length = 8
# Generate labels
labels = list(range(n_regions + 1)) # 0 is background
labels_img = generate_labeled_regions(shape, n_regions, labels=labels)
labels_data = labels_img.get_data()
# Convert to maps
maps_data = np.zeros(shape + (n_regions,))
for n, l in enumerate(labels):
if n == 0:
continue
maps_data[labels_data == l, n - 1] = 1
maps_img = nibabel.Nifti1Image(maps_data, labels_img.affine)
# Generate fake data
fmri_img, _ = generate_fake_fmri(shape=shape, length=length,
affine=labels_img.affine)
# Extract signals from maps and labels: results must be identical.
maps_signals, maps_labels = signal_extraction.img_to_signals_maps(
fmri_img, maps_img)
labels_signals, labels_labels = signal_extraction.img_to_signals_labels(
fmri_img, labels_img)
np.testing.assert_almost_equal(maps_signals, labels_signals)
# Same thing with a mask, containing only 3 regions.
mask_data = (labels_data == 1) + (labels_data == 2) + (labels_data == 5)
mask_img = nibabel.Nifti1Image(mask_data.astype(np.int8),
labels_img.affine)
labels_signals, labels_labels = signal_extraction.img_to_signals_labels(
fmri_img, labels_img, mask_img=mask_img)
maps_signals, maps_labels = signal_extraction.img_to_signals_maps(
fmri_img, maps_img, mask_img=mask_img)
np.testing.assert_almost_equal(maps_signals, labels_signals)
assert_true(maps_signals.shape[1] == n_regions)
assert_true(maps_labels == list(range(len(maps_labels))))
assert_true(labels_signals.shape == (length, n_regions))
assert_true(labels_labels == labels[1:])
# Inverse operation (mostly smoke test)
labels_img_r = signal_extraction.signals_to_img_labels(
labels_signals, labels_img, mask_img=mask_img)
assert_true(labels_img_r.shape == shape + (length,))
maps_img_r = signal_extraction.signals_to_img_maps(
maps_signals, maps_img, mask_img=mask_img)
assert_true(maps_img_r.shape == shape + (length,))
# Check that NaNs in regions inside mask are preserved
region1 = labels_data == 2
indices = [ind[:1] for ind in np.where(region1)]
fmri_img.get_data()[indices + [slice(None)]] = float('nan')
labels_signals, labels_labels = signal_extraction.img_to_signals_labels(
fmri_img, labels_img, mask_img=mask_img)
assert_true(np.all(np.isnan(labels_signals[:, labels_labels.index(2)])))
def test_signal_extraction_with_maps_and_labels():
shape = (4, 5, 6)
n_regions = 7
length = 8
# Generate labels
labels = list(range(n_regions + 1)) # 0 is background
labels_img = generate_labeled_regions(shape, n_regions, labels=labels)
labels_data = get_data(labels_img)
# Convert to maps
maps_data = np.zeros(shape + (n_regions, ))
for n, l in enumerate(labels):
if n == 0:
continue
maps_data[labels_data == l, n - 1] = 1
maps_img = nibabel.Nifti1Image(maps_data, labels_img.affine)
# Generate fake data
fmri_img, _ = generate_fake_fmri(shape=shape,
length=length,
affine=labels_img.affine)
# Extract signals from maps and labels: results must be identical.
maps_signals, maps_labels = signal_extraction.img_to_signals_maps(
fmri_img, maps_img)
labels_signals, labels_labels = signal_extraction.img_to_signals_labels(
fmri_img, labels_img)
np.testing.assert_almost_equal(maps_signals, labels_signals)
# Same thing with a mask, containing only 3 regions.
mask_data = (labels_data == 1) + (labels_data == 2) + (labels_data == 5)
mask_img = nibabel.Nifti1Image(mask_data.astype(np.int8),
labels_img.affine)
labels_signals, labels_labels = signal_extraction.img_to_signals_labels(
fmri_img, labels_img, mask_img=mask_img)
maps_signals, maps_labels = signal_extraction.img_to_signals_maps(
fmri_img, maps_img, mask_img=mask_img)
np.testing.assert_almost_equal(maps_signals, labels_signals)
assert_true(maps_signals.shape[1] == n_regions)
assert_true(maps_labels == list(range(len(maps_labels))))
assert_true(labels_signals.shape == (length, n_regions))
assert_true(labels_labels == labels[1:])
# Inverse operation (mostly smoke test)
labels_img_r = signal_extraction.signals_to_img_labels(labels_signals,
labels_img,
mask_img=mask_img)
assert_true(labels_img_r.shape == shape + (length, ))
maps_img_r = signal_extraction.signals_to_img_maps(maps_signals,
maps_img,
mask_img=mask_img)
assert_true(maps_img_r.shape == shape + (length, ))
# Check that NaNs in regions inside mask are preserved
region1 = labels_data == 2
indices = [ind[:1] for ind in np.where(region1)]
get_data(fmri_img)[indices + [slice(None)]] = float('nan')
labels_signals, labels_labels = signal_extraction.img_to_signals_labels(
fmri_img, labels_img, mask_img=mask_img)
assert_true(np.all(np.isnan(labels_signals[:, labels_labels.index(2)])))
def test_connected_label_regions():
shape = (13, 11, 12)
affine = np.eye(4)
n_regions = 9
labels_img = generate_labeled_regions(shape,
affine=affine,
n_regions=n_regions)
labels_data = get_data(labels_img)
n_labels_wo_reg_ext = len(np.unique(labels_data))
# region extraction without specifying min_size
extracted_regions_on_labels_img = connected_label_regions(labels_img)
extracted_regions_labels_data = get_data(extracted_regions_on_labels_img)
n_labels_wo_min = len(np.unique(extracted_regions_labels_data))
assert n_labels_wo_reg_ext < n_labels_wo_min
# with specifying min_size
extracted_regions_with_min = connected_label_regions(labels_img,
min_size=100)
extracted_regions_with_min_data = get_data(extracted_regions_with_min)
n_labels_with_min = len(np.unique(extracted_regions_with_min_data))
assert n_labels_wo_min > n_labels_with_min
# Test connect_diag=False
ext_reg_without_connect_diag = connected_label_regions(labels_img,
connect_diag=False)
data_wo_connect_diag = get_data(ext_reg_without_connect_diag)
n_labels_wo_connect_diag = len(np.unique(data_wo_connect_diag))
assert n_labels_wo_connect_diag > n_labels_wo_reg_ext
# If min_size is large and if all the regions are removed then empty image
# will be returned
extract_reg_min_size_large = connected_label_regions(labels_img,
min_size=500)
assert np.unique(get_data(extract_reg_min_size_large)) == 0
# Test the names of the brain regions given in labels.
# Test labels for 9 regions in n_regions
labels = [
'region_a', 'region_b', 'region_c', 'region_d', 'region_e', 'region_f',
'region_g', 'region_h', 'region_i'
]
# If labels are provided, first return will contain extracted labels image
# and second return will contain list of new names generated based on same
# name with assigned on both hemispheres for example.
extracted_reg, new_labels = connected_label_regions(labels_img,
min_size=100,
labels=labels)
# The length of new_labels returned can differ depending upon min_size. If
# min_size given is more small regions can be removed therefore newly
# generated labels can be less than original size of labels. Or if min_size
# is less then newly generated labels can be more.
# We test here whether labels returned are empty or not.
assert new_labels != ''
assert len(new_labels) <= len(labels)
# labels given in numpy array
labels = np.asarray(labels)
extracted_reg2, new_labels2 = connected_label_regions(labels_img,
labels=labels)
assert new_labels != ''
# By default min_size is less, so newly generated labels can be more.
assert len(new_labels2) >= len(labels)
# If number of labels provided are wrong (which means less than number of
# unique labels in labels_img), then we raise an error
# Test whether error raises
unique_labels = set(np.unique(np.asarray(get_data(labels_img))))
unique_labels.remove(0)
# labels given are less than n_regions=9
provided_labels = [
'region_a', 'region_c', 'region_f', 'region_g', 'region_h', 'region_i'
]
assert len(provided_labels) < len(unique_labels)
with pytest.raises(ValueError):
connected_label_regions(labels_img, labels=provided_labels)
# Test if unknown/negative integers are provided as labels in labels_img,
# we raise an error and test the same whether error is raised.
labels_data = np.zeros(shape, dtype=np.int)
h0 = shape[0] // 2
h1 = shape[1] // 2
h2 = shape[2] // 2
labels_data[:h0, :h1, :h2] = 1
labels_data[:h0, :h1, h2:] = 2
labels_data[:h0, h1:, :h2] = 3
labels_data[:h0, h1:, h2:] = 4
labels_data[h0:, :h1, :h2] = 5
labels_data[h0:, :h1, h2:] = 6
labels_data[h0:, h1:, :h2] = np.nan
labels_data[h0:, h1:, h2:] = np.inf
neg_labels_img = nibabel.Nifti1Image(labels_data, affine)
with pytest.raises(ValueError):
connected_label_regions(labels_img=neg_labels_img)
# If labels_img provided is 4D Nifti image, then test whether error is
# raised or not. Since this function accepts only 3D image.
labels_4d_data = np.zeros((shape) + (2, ))
labels_data[h0:, h1:, :h2] = 0
labels_data[h0:, h1:, h2:] = 0
labels_4d_data[..., 0] = labels_data
labels_4d_data[..., 1] = labels_data
labels_img_4d = nibabel.Nifti1Image(labels_4d_data, np.eye(4))
with pytest.raises(DimensionError):
connected_label_regions(labels_img=labels_img_4d)
# Test if labels (or names to regions) given is a string without a list.
# Then, we expect it to be split to regions extracted and returned as list.
labels_in_str = 'region_a'
labels_img_in_str = generate_labeled_regions(shape,
affine=affine,
n_regions=1)
extract_regions, new_labels = connected_label_regions(labels_img_in_str,
labels=labels_in_str)
assert isinstance(new_labels, list)
# If user has provided combination of labels, then function passes without
# breaking and new labels are returned based upon given labels and should
# be equal or more based on regions extracted
combined_labels = [
'region_a', '1', 'region_b', '2', 'region_c', '3', 'region_d', '4',
'region_e'
]
ext_reg, new_labels = connected_label_regions(labels_img,
labels=combined_labels)
assert len(new_labels) >= len(combined_labels)
def test_nifti_labels_masker_report(data_img_3d, mask):
shape = (13, 11, 12)
affine = np.diag([2, 2, 2, 1])
n_regions = 9
labels = ['background'
] + ['region_{}'.format(i) for i in range(1, n_regions + 1)]
EXPECTED_COLUMNS = [
'label value', 'region name', 'size (in mm^3)', 'relative size (in %)'
]
labels_img = generate_labeled_regions(shape,
affine=affine,
n_regions=n_regions)
labels_img_floats = new_img_like(labels_img,
get_data(labels_img).astype(float))
masker = NiftiLabelsMasker(labels_img_floats, labels=labels)
masker.fit()
masker.generate_report()
# Check that providing incorrect labels raises an error
masker = NiftiLabelsMasker(labels_img, labels=labels[:-1])
masker.fit()
with pytest.raises(ValueError,
match="Mismatch between the number of provided labels"):
masker.generate_report()
masker = NiftiLabelsMasker(labels_img, labels=labels)
masker.fit()
# Check that a warning is given when generating the report
# since no image was provided to fit
with pytest.warns(UserWarning,
match="No image provided to fit in NiftiLabelsMasker"):
masker.generate_report()
# No image was provided to fit, regions are plotted using
# plot_roi such that no contour should be in the image
display = masker._reporting()
for d in ['x', 'y', 'z']:
assert len(display[0].axes[d].ax.collections) == 0
masker = NiftiLabelsMasker(labels_img, labels=labels)
masker.fit(data_img_3d)
display = masker._reporting()
for d in ['x', 'y', 'z']:
assert len(display[0].axes[d].ax.collections) > 0
assert len(display[0].axes[d].ax.collections) <= n_regions
masker = NiftiLabelsMasker(labels_img, labels=labels, mask_img=mask)
masker.fit(data_img_3d)
report = masker.generate_report()
assert masker._reporting_data is not None
# Check that background label was left as default
assert masker.background_label == 0
assert masker._report_content['description'] == (
'This reports shows the regions defined by the labels of the mask.')
# Check that the number of regions is correct
assert masker._report_content['number_of_regions'] == n_regions
# Check that all expected columns are present with the right size
for col in EXPECTED_COLUMNS:
assert col in masker._report_content['summary']
assert len(masker._report_content['summary'][col]) == n_regions
# Check that labels match
assert masker._report_content['summary']['region name'] == labels[1:]
# Relative sizes of regions should sum to 100%
assert_almost_equal(
sum(masker._report_content['summary']['relative size (in %)']), 100)
_check_html(report)
assert "Regions summary" in str(report)
# Check region sizes calculations
expected_region_sizes = Counter(get_data(labels_img).ravel())
for r in range(1, n_regions + 1):
assert_almost_equal(
masker._report_content['summary']['size (in mm^3)'][r - 1],
expected_region_sizes[r] * np.abs(np.linalg.det(affine[:3, :3])))
# Check that region labels are no displayed in the report
# when they were not provided by the user.
masker = NiftiLabelsMasker(labels_img)
masker.fit()
report = masker.generate_report()
for col in EXPECTED_COLUMNS:
if col == "region name":
assert col not in masker._report_content["summary"]
else:
assert col in masker._report_content["summary"]
assert len(masker._report_content['summary'][col]) == n_regions
def test_nifti_labels_masker_resampling():
# Test resampling in NiftiLabelsMasker
shape1 = (10, 11, 12)
affine = np.eye(4)
# mask
shape2 = (16, 17, 18)
# labels
shape3 = (13, 14, 15)
n_regions = 9
length = 3
# With data of the same affine
fmri11_img, _ = generate_random_img(shape1, affine=affine,
length=length)
_, mask22_img = generate_random_img(shape2, affine=affine,
length=length)
labels33_img = data_gen.generate_labeled_regions(shape3, n_regions,
affine=affine)
# Test error checking
assert_raises(ValueError, NiftiLabelsMasker, labels33_img,
resampling_target="mask")
assert_raises(ValueError, NiftiLabelsMasker, labels33_img,
resampling_target="invalid")
# Target: labels
masker = NiftiLabelsMasker(labels33_img, mask_img=mask22_img,
resampling_target="labels")
masker.fit()
np.testing.assert_almost_equal(masker.labels_img_.affine,
labels33_img.affine)
assert_equal(masker.labels_img_.shape, labels33_img.shape)
np.testing.assert_almost_equal(masker.mask_img_.affine,
masker.labels_img_.affine)
assert_equal(masker.mask_img_.shape, masker.labels_img_.shape[:3])
transformed = masker.transform(fmri11_img)
assert_equal(transformed.shape, (length, n_regions))
fmri11_img_r = masker.inverse_transform(transformed)
np.testing.assert_almost_equal(fmri11_img_r.affine,
masker.labels_img_.affine)
assert_equal(fmri11_img_r.shape,
(masker.labels_img_.shape[:3] + (length,)))
# Test with clipped labels: mask does not contain all labels.
# Shapes do matter in that case, because there is some resampling
# taking place.
shape1 = (10, 11, 12) # fmri
shape2 = (8, 9, 10) # mask
shape3 = (16, 18, 20) # maps
n_regions = 9
length = 21
fmri11_img, _ = generate_random_img(shape1, affine=affine,
length=length)
_, mask22_img = generate_random_img(shape2, affine=affine,
length=length)
# Target: labels
labels33_img = data_gen.generate_labeled_regions(shape3, n_regions,
affine=affine)
masker = NiftiLabelsMasker(labels33_img, mask_img=mask22_img,
resampling_target="labels")
masker.fit()
np.testing.assert_almost_equal(masker.labels_img_.affine,
labels33_img.affine)
assert_equal(masker.labels_img_.shape, labels33_img.shape)
np.testing.assert_almost_equal(masker.mask_img_.affine,
masker.labels_img_.affine)
assert_equal(masker.mask_img_.shape, masker.labels_img_.shape[:3])
uniq_labels = np.unique(masker.labels_img_.get_data())
assert_equal(uniq_labels[0], 0)
assert_equal(len(uniq_labels) - 1, n_regions)
transformed = masker.transform(fmri11_img)
assert_equal(transformed.shape, (length, n_regions))
# Some regions have been clipped. Resulting signal must be zero
assert_less((transformed.var(axis=0) == 0).sum(), n_regions)
fmri11_img_r = masker.inverse_transform(transformed)
np.testing.assert_almost_equal(fmri11_img_r.affine,
masker.labels_img_.affine)
assert_equal(fmri11_img_r.shape,
(masker.labels_img_.shape[:3] + (length,)))
# Test with data and atlas of different shape: the atlas should be
# resampled to the data
shape22 = (5, 5, 6)
affine2 = 2 * np.eye(4)
affine2[-1, -1] = 1
fmri22_img, _ = generate_random_img(shape22, affine=affine2,
length=length)
masker = NiftiLabelsMasker(labels33_img, mask_img=mask22_img)
masker.fit_transform(fmri22_img)
np.testing.assert_array_equal(masker._resampled_labels_img_.affine,
affine2)
# Test with filenames
with testing.write_tmp_imgs(fmri22_img) as filename:
masker = NiftiLabelsMasker(labels33_img, resampling_target='data')
masker.fit_transform(filename)
# test labels masker with resampling target in 'data', 'labels' to return
# resampled labels having number of labels equal with transformed shape of
# 2nd dimension. This tests are added based on issue #1673 in Nilearn
shape = (13, 11, 12)
affine = np.eye(4) * 2
fmri_img, _ = generate_random_img(shape, affine=affine, length=21)
labels_img = data_gen.generate_labeled_regions((9, 8, 6), affine=np.eye(4),
n_regions=10)
for resampling_target in ['data', 'labels']:
masker = NiftiLabelsMasker(labels_img=labels_img,
resampling_target=resampling_target)
transformed = masker.fit_transform(fmri_img)
resampled_labels_img = masker._resampled_labels_img_
n_resampled_labels = len(np.unique(resampled_labels_img.get_data()))
assert_equal(n_resampled_labels - 1, transformed.shape[1])
# inverse transform
compressed_img = masker.inverse_transform(transformed)
# Test that compressing the image a second time should yield an image
# with the same data as compressed_img.
transformed2 = masker.fit_transform(fmri_img)
# inverse transform again
compressed_img2 = masker.inverse_transform(transformed2)
np.testing.assert_array_equal(compressed_img.get_data(),
compressed_img2.get_data())
def test_nifti_labels_masker():
# Check working of shape/affine checks
shape1 = (13, 11, 12)
affine1 = np.eye(4)
shape2 = (12, 10, 14)
affine2 = np.diag((1, 2, 3, 1))
n_regions = 9
length = 3
fmri11_img, mask11_img = generate_random_img(shape1, affine=affine1,
length=length)
fmri12_img, mask12_img = generate_random_img(shape1, affine=affine2,
length=length)
fmri21_img, mask21_img = generate_random_img(shape2, affine=affine1,
length=length)
labels11_img = data_gen.generate_labeled_regions(shape1, affine=affine1,
n_regions=n_regions)
mask_img_4d = nibabel.Nifti1Image(np.ones((2, 2, 2, 2), dtype=np.int8),
affine=np.diag((4, 4, 4, 1)))
# verify that 4D mask arguments are refused
masker = NiftiLabelsMasker(labels11_img, mask_img=mask_img_4d)
testing.assert_raises_regex(DimensionError,
"Input data has incompatible dimensionality: "
"Expected dimension is 3D and you provided "
"a 4D image.",
masker.fit)
# check exception when transform() called without prior fit()
masker11 = NiftiLabelsMasker(labels11_img, resampling_target=None)
testing.assert_raises_regex(
ValueError, 'has not been fitted. ', masker11.transform, fmri11_img)
# No exception raised here
signals11 = masker11.fit().transform(fmri11_img)
assert_equal(signals11.shape, (length, n_regions))
masker11 = NiftiLabelsMasker(labels11_img, mask_img=mask11_img,
resampling_target=None)
signals11 = masker11.fit().transform(fmri11_img)
assert_equal(signals11.shape, (length, n_regions))
# Test all kinds of mismatch between shapes and between affines
masker11 = NiftiLabelsMasker(labels11_img, resampling_target=None)
masker11.fit()
assert_raises(ValueError, masker11.transform, fmri12_img)
assert_raises(ValueError, masker11.transform, fmri21_img)
masker11 = NiftiLabelsMasker(labels11_img, mask_img=mask12_img,
resampling_target=None)
assert_raises(ValueError, masker11.fit)
masker11 = NiftiLabelsMasker(labels11_img, mask_img=mask21_img,
resampling_target=None)
assert_raises(ValueError, masker11.fit)
# Transform, with smoothing (smoke test)
masker11 = NiftiLabelsMasker(labels11_img, smoothing_fwhm=3,
resampling_target=None)
signals11 = masker11.fit().transform(fmri11_img)
assert_equal(signals11.shape, (length, n_regions))
masker11 = NiftiLabelsMasker(labels11_img, smoothing_fwhm=3,
resampling_target=None)
signals11 = masker11.fit_transform(fmri11_img)
assert_equal(signals11.shape, (length, n_regions))
testing.assert_raises_regex(
ValueError, 'has not been fitted. ',
NiftiLabelsMasker(labels11_img).inverse_transform, signals11)
# Call inverse transform (smoke test)
fmri11_img_r = masker11.inverse_transform(signals11)
assert_equal(fmri11_img_r.shape, fmri11_img.shape)
np.testing.assert_almost_equal(fmri11_img_r.affine, fmri11_img.affine)
def test_nifti_labels_masker():
# Check working of shape/affine checks
shape1 = (13, 11, 12)
affine1 = np.eye(4)
shape2 = (12, 10, 14)
affine2 = np.diag((1, 2, 3, 1))
n_regions = 9
length = 3
fmri11_img, mask11_img = generate_random_img(shape1,
affine=affine1,
length=length)
fmri12_img, mask12_img = generate_random_img(shape1,
affine=affine2,
length=length)
fmri21_img, mask21_img = generate_random_img(shape2,
affine=affine1,
length=length)
labels11_img = data_gen.generate_labeled_regions(shape1,
affine=affine1,
n_regions=n_regions)
mask_img_4d = nibabel.Nifti1Image(np.ones((2, 2, 2, 2), dtype=np.int8),
affine=np.diag((4, 4, 4, 1)))
# verify that 4D mask arguments are refused
masker = NiftiLabelsMasker(labels11_img, mask_img=mask_img_4d)
with pytest.raises(DimensionError,
match="Input data has incompatible dimensionality: "
"Expected dimension is 3D and you provided "
"a 4D image."):
masker.fit()
# check exception when transform() called without prior fit()
masker11 = NiftiLabelsMasker(labels11_img, resampling_target=None)
with pytest.raises(ValueError, match='has not been fitted. '):
masker11.transform(fmri11_img)
# No exception raised here
signals11 = masker11.fit().transform(fmri11_img)
assert signals11.shape == (length, n_regions)
# No exception should be raised either
masker11 = NiftiLabelsMasker(labels11_img, resampling_target=None)
masker11.fit()
masker11.inverse_transform(signals11)
masker11 = NiftiLabelsMasker(labels11_img,
mask_img=mask11_img,
resampling_target=None)
signals11 = masker11.fit().transform(fmri11_img)
assert signals11.shape == (length, n_regions)
# Test all kinds of mismatch between shapes and between affines
masker11 = NiftiLabelsMasker(labels11_img, resampling_target=None)
masker11.fit()
pytest.raises(ValueError, masker11.transform, fmri12_img)
pytest.raises(ValueError, masker11.transform, fmri21_img)
masker11 = NiftiLabelsMasker(labels11_img,
mask_img=mask12_img,
resampling_target=None)
pytest.raises(ValueError, masker11.fit)
masker11 = NiftiLabelsMasker(labels11_img,
mask_img=mask21_img,
resampling_target=None)
pytest.raises(ValueError, masker11.fit)
# Transform, with smoothing (smoke test)
masker11 = NiftiLabelsMasker(labels11_img,
smoothing_fwhm=3,
resampling_target=None)
signals11 = masker11.fit().transform(fmri11_img)
assert signals11.shape == (length, n_regions)
masker11 = NiftiLabelsMasker(labels11_img,
smoothing_fwhm=3,
resampling_target=None)
signals11 = masker11.fit_transform(fmri11_img)
assert signals11.shape == (length, n_regions)
with pytest.raises(ValueError, match='has not been fitted. '):
NiftiLabelsMasker(labels11_img).inverse_transform(signals11)
# Call inverse transform (smoke test)
fmri11_img_r = masker11.inverse_transform(signals11)
assert fmri11_img_r.shape == fmri11_img.shape
np.testing.assert_almost_equal(fmri11_img_r.affine, fmri11_img.affine)
def test_nifti_labels_masker_resampling():
# Test resampling in NiftiLabelsMasker
shape1 = (10, 11, 12)
affine = np.eye(4)
# mask
shape2 = (16, 17, 18)
# labels
shape3 = (13, 14, 15)
n_regions = 9
length = 3
# With data of the same affine
fmri11_img, _ = generate_random_img(shape1, affine=affine, length=length)
_, mask22_img = generate_random_img(shape2, affine=affine, length=length)
labels33_img = data_gen.generate_labeled_regions(shape3,
n_regions,
affine=affine)
# Test error checking
pytest.raises(ValueError,
NiftiLabelsMasker,
labels33_img,
resampling_target="mask")
pytest.raises(ValueError,
NiftiLabelsMasker,
labels33_img,
resampling_target="invalid")
# Target: labels
masker = NiftiLabelsMasker(labels33_img,
mask_img=mask22_img,
resampling_target="labels")
masker.fit()
np.testing.assert_almost_equal(masker.labels_img_.affine,
labels33_img.affine)
assert masker.labels_img_.shape == labels33_img.shape
np.testing.assert_almost_equal(masker.mask_img_.affine,
masker.labels_img_.affine)
assert masker.mask_img_.shape == masker.labels_img_.shape[:3]
transformed = masker.transform(fmri11_img)
assert transformed.shape == (length, n_regions)
fmri11_img_r = masker.inverse_transform(transformed)
np.testing.assert_almost_equal(fmri11_img_r.affine,
masker.labels_img_.affine)
assert (fmri11_img_r.shape == (masker.labels_img_.shape[:3] + (length, )))
# Test with clipped labels: mask does not contain all labels.
# Shapes do matter in that case, because there is some resampling
# taking place.
shape1 = (10, 11, 12) # fmri
shape2 = (8, 9, 10) # mask
shape3 = (16, 18, 20) # maps
n_regions = 9
length = 21
fmri11_img, _ = generate_random_img(shape1, affine=affine, length=length)
_, mask22_img = generate_random_img(shape2, affine=affine, length=length)
# Target: labels
labels33_img = data_gen.generate_labeled_regions(shape3,
n_regions,
affine=affine)
masker = NiftiLabelsMasker(labels33_img,
mask_img=mask22_img,
resampling_target="labels")
masker.fit()
np.testing.assert_almost_equal(masker.labels_img_.affine,
labels33_img.affine)
assert masker.labels_img_.shape == labels33_img.shape
np.testing.assert_almost_equal(masker.mask_img_.affine,
masker.labels_img_.affine)
assert masker.mask_img_.shape == masker.labels_img_.shape[:3]
uniq_labels = np.unique(get_data(masker.labels_img_))
assert uniq_labels[0] == 0
assert len(uniq_labels) - 1 == n_regions
transformed = masker.transform(fmri11_img)
assert transformed.shape == (length, n_regions)
# Some regions have been clipped. Resulting signal must be zero
assert (transformed.var(axis=0) == 0).sum() < n_regions
fmri11_img_r = masker.inverse_transform(transformed)
np.testing.assert_almost_equal(fmri11_img_r.affine,
masker.labels_img_.affine)
assert (fmri11_img_r.shape == (masker.labels_img_.shape[:3] + (length, )))
# Test with data and atlas of different shape: the atlas should be
# resampled to the data
shape22 = (5, 5, 6)
affine2 = 2 * np.eye(4)
affine2[-1, -1] = 1
fmri22_img, _ = generate_random_img(shape22, affine=affine2, length=length)
masker = NiftiLabelsMasker(labels33_img, mask_img=mask22_img)
masker.fit_transform(fmri22_img)
np.testing.assert_array_equal(masker._resampled_labels_img_.affine,
affine2)
# Test with filenames
with testing.write_tmp_imgs(fmri22_img) as filename:
masker = NiftiLabelsMasker(labels33_img, resampling_target='data')
masker.fit_transform(filename)
# test labels masker with resampling target in 'data', 'labels' to return
# resampled labels having number of labels equal with transformed shape of
# 2nd dimension. This tests are added based on issue #1673 in Nilearn
shape = (13, 11, 12)
affine = np.eye(4) * 2
fmri_img, _ = generate_random_img(shape, affine=affine, length=21)
labels_img = data_gen.generate_labeled_regions((9, 8, 6),
affine=np.eye(4),
n_regions=10)
for resampling_target in ['data', 'labels']:
masker = NiftiLabelsMasker(labels_img=labels_img,
resampling_target=resampling_target)
if resampling_target == 'data':
with pytest.warns(UserWarning,
match=("After resampling the label image "
"to the data image, the following "
"labels were removed")):
transformed = masker.fit_transform(fmri_img)
else:
transformed = masker.fit_transform(fmri_img)
resampled_labels_img = masker._resampled_labels_img_
n_resampled_labels = len(np.unique(get_data(resampled_labels_img)))
assert n_resampled_labels - 1 == transformed.shape[1]
# inverse transform
compressed_img = masker.inverse_transform(transformed)
# Test that compressing the image a second time should yield an image
# with the same data as compressed_img.
transformed2 = masker.fit_transform(fmri_img)
# inverse transform again
compressed_img2 = masker.inverse_transform(transformed2)
np.testing.assert_array_equal(get_data(compressed_img),
get_data(compressed_img2))
def test_connected_label_regions():
shape = (13, 11, 12)
affine = np.eye(4)
n_regions = 9
labels_img = generate_labeled_regions(shape, affine=affine,
n_regions=n_regions)
labels_data = labels_img.get_data()
n_labels_wo_reg_ext = len(np.unique(labels_data))
# region extraction without specifying min_size
extracted_regions_on_labels_img = connected_label_regions(labels_img)
extracted_regions_labels_data = extracted_regions_on_labels_img.get_data()
n_labels_wo_min = len(np.unique(extracted_regions_labels_data))
assert_true(n_labels_wo_reg_ext < n_labels_wo_min)
# with specifying min_size
extracted_regions_with_min = connected_label_regions(labels_img,
min_size=100)
extracted_regions_with_min_data = extracted_regions_with_min.get_data()
n_labels_with_min = len(np.unique(extracted_regions_with_min_data))
assert_true(n_labels_wo_min > n_labels_with_min)
# Test connect_diag=False
ext_reg_without_connect_diag = connected_label_regions(labels_img,
connect_diag=False)
data_wo_connect_diag = ext_reg_without_connect_diag.get_data()
n_labels_wo_connect_diag = len(np.unique(data_wo_connect_diag))
assert_true(n_labels_wo_connect_diag > n_labels_wo_reg_ext)
# If min_size is large and if all the regions are removed then empty image
# will be returned
extract_reg_min_size_large = connected_label_regions(labels_img,
min_size=500)
assert_true(np.unique(extract_reg_min_size_large.get_data()) == 0)
# Test the names of the brain regions given in labels.
# Test labels for 9 regions in n_regions
labels = ['region_a', 'region_b', 'region_c', 'region_d', 'region_e',
'region_f', 'region_g', 'region_h', 'region_i']
# If labels are provided, first return will contain extracted labels image
# and second return will contain list of new names generated based on same
# name with assigned on both hemispheres for example.
extracted_reg, new_labels = connected_label_regions(labels_img,
min_size=100,
labels=labels)
# The length of new_labels returned can differ depending upon min_size. If
# min_size given is more small regions can be removed therefore newly
# generated labels can be less than original size of labels. Or if min_size
# is less then newly generated labels can be more.
# We test here whether labels returned are empty or not.
assert_not_equal(new_labels, '')
assert_true(len(new_labels) <= len(labels))
# labels given in numpy array
labels = np.asarray(labels)
extracted_reg2, new_labels2 = connected_label_regions(labels_img,
labels=labels)
assert_not_equal(new_labels, '')
# By default min_size is less, so newly generated labels can be more.
assert_true(len(new_labels2) >= len(labels))
# If number of labels provided are wrong (which means less than number of
# unique labels in labels_img), then we raise an error
# Test whether error raises
unique_labels = set(np.unique(np.asarray(labels_img.get_data())))
unique_labels.remove(0)
# labels given are less than n_regions=9
provided_labels = ['region_a', 'region_c', 'region_f',
'region_g', 'region_h', 'region_i']
assert_true(len(provided_labels) < len(unique_labels))
np.testing.assert_raises(ValueError, connected_label_regions,
labels_img, labels=provided_labels)
# Test if unknown/negative integers are provided as labels in labels_img,
# we raise an error and test the same whether error is raised.
labels_data = np.zeros(shape, dtype=np.int)
h0 = shape[0] // 2
h1 = shape[1] // 2
h2 = shape[2] // 2
labels_data[:h0, :h1, :h2] = 1
labels_data[:h0, :h1, h2:] = 2
labels_data[:h0, h1:, :h2] = 3
labels_data[:h0, h1:, h2:] = 4
labels_data[h0:, :h1, :h2] = 5
labels_data[h0:, :h1, h2:] = 6
labels_data[h0:, h1:, :h2] = np.nan
labels_data[h0:, h1:, h2:] = np.inf
neg_labels_img = nibabel.Nifti1Image(labels_data, affine)
np.testing.assert_raises(ValueError, connected_label_regions,
labels_img=neg_labels_img)
# If labels_img provided is 4D Nifti image, then test whether error is
# raised or not. Since this function accepts only 3D image.
labels_4d_data = np.zeros((shape) + (2, ))
labels_data[h0:, h1:, :h2] = 0
labels_data[h0:, h1:, h2:] = 0
labels_4d_data[..., 0] = labels_data
labels_4d_data[..., 1] = labels_data
labels_img_4d = nibabel.Nifti1Image(labels_4d_data, np.eye(4))
np.testing.assert_raises(DimensionError, connected_label_regions,
labels_img=labels_img_4d)
# Test if labels (or names to regions) given is a string without a list.
# Then, we expect it to be split to regions extracted and returned as list.
labels_in_str = 'region_a'
labels_img_in_str = generate_labeled_regions(shape, affine=affine,
n_regions=1)
extract_regions, new_labels = connected_label_regions(labels_img_in_str,
labels=labels_in_str)
assert_true(isinstance(new_labels, list))
# If user has provided combination of labels, then function passes without
# breaking and new labels are returned based upon given labels and should
# be equal or more based on regions extracted
combined_labels = ['region_a', '1', 'region_b', '2', 'region_c', '3',
'region_d', '4', 'region_e']
ext_reg, new_labels = connected_label_regions(labels_img,
labels=combined_labels)
assert_true(len(new_labels) >= len(combined_labels))
def test_largest_cc_img():
""" Check the extraction of the largest connected component, for niftis
Similiar to smooth_img tests for largest connected_component_img, here also
only the added features for largest_connected_component are tested.
"""
# Test whether dimension of 3Dimg and list of 3Dimgs are kept.
shapes = ((10, 11, 12), (13, 14, 15))
regions = [1, 3]
img1 = data_gen.generate_labeled_regions(shape=shapes[0],
n_regions=regions[0])
img2 = data_gen.generate_labeled_regions(shape=shapes[1],
n_regions=regions[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 = largest_connected_component_img(imgs)
assert_true(isinstance(out, list))
assert_true(len(out) == 2)
for o, s in zip(out, shapes):
assert_true(o.shape == (s))
# Single image as input
out = largest_connected_component_img(imgs[0])
assert_true(isinstance(out, Nifti1Image))
assert_true(out.shape == (shapes[0]))
# Test whether 4D Nifti throws the right error.
img_4D = data_gen.generate_fake_fmri(shapes[0], length=17)
assert_raises(DimensionError, largest_connected_component_img, img_4D)
# tests adapted to non-native endian data dtype
img1_change_dtype = nibabel.Nifti1Image(img1.get_data().astype('>f8'),
affine=img1.affine)
img2_change_dtype = nibabel.Nifti1Image(img2.get_data().astype('>f8'),
affine=img2.affine)
for create_files in (False, True):
with testing.write_tmp_imgs(img1_change_dtype, img2_change_dtype,
create_files=create_files) as imgs:
# List of images as input
out = largest_connected_component_img(imgs)
assert_true(isinstance(out, list))
assert_true(len(out) == 2)
for o, s in zip(out, shapes):
assert_true(o.shape == (s))
# Single image as input
out = largest_connected_component_img(imgs[0])
assert_true(isinstance(out, Nifti1Image))
assert_true(out.shape == (shapes[0]))
# Test the output with native and without native
out_native = largest_connected_component_img(img1)
out_non_native = largest_connected_component_img(img1_change_dtype)
np.testing.assert_equal(out_native.get_data(), out_non_native.get_data())
