def test_signals_extraction_with_labels():
"""Test conversion between signals and images using regions defined
by labels."""
shape = (8, 9, 10)
n_instants = 11
n_regions = 8 # must be 8
eps = np.finfo(np.float).eps
# data
affine = np.eye(4)
signals = generate_timeseries(n_instants, n_regions)
# mask
mask_data = np.zeros(shape)
mask_data[1:-1, 1:-1, 1:-1] = 1
mask_img = nibabel.Nifti1Image(mask_data, affine)
mask_4d_img = nibabel.Nifti1Image(np.ones(shape + (2, )), affine)
# labels
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] = 7
labels_data[h0:, h1:, h2:] = 8
labels_img = nibabel.Nifti1Image(labels_data, affine)
labels_4d_data = np.zeros((shape) + (2, ))
labels_4d_data[..., 0] = labels_data
labels_4d_data[..., 1] = labels_data
labels_4d_img = nibabel.Nifti1Image(labels_4d_data, np.eye(4))
## Without mask
# from labels
data_img = region.signals_to_img_labels(signals, labels_img)
data = data_img.get_data()
assert_true(data_img.shape == (shape + (n_instants, )))
assert_true(np.all(data.std(axis=-1) > 0))
# verify that 4D label images are refused
assert_raises_regex(DimensionError, "Data must be a 3D",
region.img_to_signals_labels, data_img, labels_4d_img)
# There must be non-zero data (safety net)
assert_true(abs(data).max() > 1e-9)
# Check that signals in each region are identical in each voxel
for n in range(1, n_regions + 1):
sigs = data[labels_data == n, :]
np.testing.assert_almost_equal(sigs[0, :], signals[:, n - 1])
assert_true(abs(sigs - sigs[0, :]).max() < eps)
# and back
signals_r, labels_r = region.img_to_signals_labels(data_img, labels_img)
np.testing.assert_almost_equal(signals_r, signals)
assert_true(labels_r == list(range(1, 9)))
with write_tmp_imgs(data_img) as fname_img:
signals_r, labels_r = region.img_to_signals_labels(
fname_img, labels_img)
np.testing.assert_almost_equal(signals_r, signals)
assert_true(labels_r == list(range(1, 9)))
## Same thing, with mask.
assert_raises_regex(DimensionError,
"Data must be a 3D",
region.img_to_signals_labels,
data_img,
labels_img,
mask_img=mask_4d_img)
assert_raises_regex(DimensionError,
"Data must be a 3D",
region.signals_to_img_labels,
data_img,
labels_img,
mask_img=mask_4d_img)
data_img = region.signals_to_img_labels(signals,
labels_img,
mask_img=mask_img)
assert_raises(TypeError,
region.signals_to_img_labels,
data_img,
labels_4d_img,
mask_img=mask_img)
assert_true(data_img.shape == (shape + (n_instants, )))
data = data_img.get_data()
assert_true(abs(data).max() > 1e-9)
# Zero outside of the mask
assert_true(
np.all(data[np.logical_not(mask_img.get_data())].std(axis=-1) < eps))
with write_tmp_imgs(labels_img, mask_img) as filenames:
data_img = region.signals_to_img_labels(signals,
filenames[0],
mask_img=filenames[1])
assert_true(data_img.shape == (shape + (n_instants, )))
data = data_img.get_data()
assert_true(abs(data).max() > 1e-9)
# Zero outside of the mask
assert_true(
np.all(
data[np.logical_not(mask_img.get_data())].std(axis=-1) < eps))
# mask labels before checking
masked_labels_data = labels_data.copy()
masked_labels_data[np.logical_not(mask_img.get_data())] = 0
for n in range(1, n_regions + 1):
sigs = data[masked_labels_data == n, :]
np.testing.assert_almost_equal(sigs[0, :], signals[:, n - 1])
assert_true(abs(sigs - sigs[0, :]).max() < eps)
# and back
signals_r, labels_r = region.img_to_signals_labels(data_img,
labels_img,
mask_img=mask_img)
np.testing.assert_almost_equal(signals_r, signals)
assert_true(labels_r == list(range(1, 9)))
# Test input validation
data_img = nibabel.Nifti1Image(np.zeros((2, 3, 4, 5)), np.eye(4))
good_labels_img = nibabel.Nifti1Image(np.zeros((2, 3, 4)), np.eye(4))
bad_labels1_img = nibabel.Nifti1Image(np.zeros((2, 3, 5)), np.eye(4))
bad_labels2_img = nibabel.Nifti1Image(np.zeros((2, 3, 4)), 2 * np.eye(4))
good_mask_img = nibabel.Nifti1Image(np.zeros((2, 3, 4)), np.eye(4))
bad_mask1_img = nibabel.Nifti1Image(np.zeros((2, 3, 5)), np.eye(4))
bad_mask2_img = nibabel.Nifti1Image(np.zeros((2, 3, 4)), 2 * np.eye(4))
assert_raises(ValueError, region.img_to_signals_labels, data_img,
bad_labels1_img)
assert_raises(ValueError, region.img_to_signals_labels, data_img,
bad_labels2_img)
assert_raises(ValueError,
region.img_to_signals_labels,
data_img,
bad_labels1_img,
mask_img=good_mask_img)
assert_raises(ValueError,
region.img_to_signals_labels,
data_img,
bad_labels2_img,
mask_img=good_mask_img)
assert_raises(ValueError,
region.img_to_signals_labels,
data_img,
good_labels_img,
mask_img=bad_mask1_img)
assert_raises(ValueError,
region.img_to_signals_labels,
data_img,
good_labels_img,
mask_img=bad_mask2_img)
def test_signals_extraction_with_labels():
"""Test conversion between signals and images using regions defined
by labels."""
shape = (8, 9, 10)
n_instants = 11
n_regions = 8 # must be 8
eps = np.finfo(np.float).eps
# data
affine = np.eye(4)
signals = generate_timeseries(n_instants, n_regions)
# mask
mask_data = np.zeros(shape)
mask_data[1:-1, 1:-1, 1:-1] = 1
mask_img = nibabel.Nifti1Image(mask_data, affine)
mask_4d_img = nibabel.Nifti1Image(np.ones(shape + (2, )), affine)
# labels
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] = 7
labels_data[h0:, h1:, h2:] = 8
labels_img = nibabel.Nifti1Image(labels_data, affine)
labels_4d_data = np.zeros((shape) + (2, ))
labels_4d_data[..., 0] = labels_data
labels_4d_data[..., 1] = labels_data
labels_4d_img = nibabel.Nifti1Image(labels_4d_data, np.eye(4))
## Without mask
# from labels
data_img = region.signals_to_img_labels(signals, labels_img)
data = data_img.get_data()
assert_true(data_img.shape == (shape + (n_instants,)))
assert_true(np.all(data.std(axis=-1) > 0))
# verify that 4D label images are refused
assert_raises_regex(TypeError, "A 3D image is expected",
region.img_to_signals_labels, data_img, labels_4d_img)
# There must be non-zero data (safety net)
assert_true(abs(data).max() > 1e-9)
# Check that signals in each region are identical in each voxel
for n in range(1, n_regions + 1):
sigs = data[labels_data == n, :]
np.testing.assert_almost_equal(sigs[0, :], signals[:, n - 1])
assert_true(abs(sigs - sigs[0, :]).max() < eps)
# and back
signals_r, labels_r = region.img_to_signals_labels(data_img, labels_img)
np.testing.assert_almost_equal(signals_r, signals)
assert_true(labels_r == list(range(1, 9)))
with write_tmp_imgs(data_img) as fname_img:
signals_r, labels_r = region.img_to_signals_labels(fname_img,
labels_img)
np.testing.assert_almost_equal(signals_r, signals)
assert_true(labels_r == list(range(1, 9)))
## Same thing, with mask.
assert_raises_regex(TypeError, "A 3D image is expected",
region.img_to_signals_labels, data_img, labels_img,
mask_img=mask_4d_img)
assert_raises_regex(TypeError, "A 3D image is expected",
region.signals_to_img_labels, data_img, labels_img,
mask_img=mask_4d_img)
data_img = region.signals_to_img_labels(signals, labels_img,
mask_img=mask_img)
assert_raises(TypeError, region.signals_to_img_labels,
data_img, labels_4d_img, mask_img=mask_img)
assert_true(data_img.shape == (shape + (n_instants,)))
data = data_img.get_data()
assert_true(abs(data).max() > 1e-9)
# Zero outside of the mask
assert_true(np.all(data[np.logical_not(mask_img.get_data())
].std(axis=-1) < eps)
)
with write_tmp_imgs(labels_img, mask_img) as filenames:
data_img = region.signals_to_img_labels(signals, filenames[0],
mask_img=filenames[1])
assert_true(data_img.shape == (shape + (n_instants,)))
data = data_img.get_data()
assert_true(abs(data).max() > 1e-9)
# Zero outside of the mask
assert_true(np.all(data[np.logical_not(mask_img.get_data())
].std(axis=-1) < eps)
)
# mask labels before checking
masked_labels_data = labels_data.copy()
masked_labels_data[np.logical_not(mask_img.get_data())] = 0
for n in range(1, n_regions + 1):
sigs = data[masked_labels_data == n, :]
np.testing.assert_almost_equal(sigs[0, :], signals[:, n - 1])
assert_true(abs(sigs - sigs[0, :]).max() < eps)
# and back
signals_r, labels_r = region.img_to_signals_labels(data_img, labels_img,
mask_img=mask_img)
np.testing.assert_almost_equal(signals_r, signals)
assert_true(labels_r == list(range(1, 9)))
# Test input validation
data_img = nibabel.Nifti1Image(np.zeros((2, 3, 4, 5)), np.eye(4))
good_labels_img = nibabel.Nifti1Image(np.zeros((2, 3, 4)), np.eye(4))
bad_labels1_img = nibabel.Nifti1Image(np.zeros((2, 3, 5)), np.eye(4))
bad_labels2_img = nibabel.Nifti1Image(np.zeros((2, 3, 4)), 2 * np.eye(4))
good_mask_img = nibabel.Nifti1Image(np.zeros((2, 3, 4)), np.eye(4))
bad_mask1_img = nibabel.Nifti1Image(np.zeros((2, 3, 5)), np.eye(4))
bad_mask2_img = nibabel.Nifti1Image(np.zeros((2, 3, 4)), 2 * np.eye(4))
assert_raises(ValueError, region.img_to_signals_labels, data_img,
bad_labels1_img)
assert_raises(ValueError, region.img_to_signals_labels, data_img,
bad_labels2_img)
assert_raises(ValueError, region.img_to_signals_labels, data_img,
bad_labels1_img, mask_img=good_mask_img)
assert_raises(ValueError, region.img_to_signals_labels, data_img,
bad_labels2_img, mask_img=good_mask_img)
assert_raises(ValueError, region.img_to_signals_labels, data_img,
good_labels_img, mask_img=bad_mask1_img)
assert_raises(ValueError, region.img_to_signals_labels, data_img,
good_labels_img, mask_img=bad_mask2_img)
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.get_affine())
# Generate fake data
fmri_img, _ = generate_fake_fmri(shape=shape,
length=length,
affine=labels_img.get_affine())
# Extract signals from maps and labels: results must be identical.
maps_signals, maps_labels = region.img_to_signals_maps(fmri_img, maps_img)
labels_signals, labels_labels =\
region.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.get_affine())
labels_signals, labels_labels =\
region.img_to_signals_labels(fmri_img, labels_img,
mask_img=mask_img)
maps_signals, maps_labels = \
region.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 = region.signals_to_img_labels(labels_signals,
labels_img,
mask_img=mask_img)
assert_true(labels_img_r.shape == shape + (length, ))
maps_img_r = region.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 =\
region.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 = 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.get_affine())
# Generate fake data
fmri_img, _ = generate_fake_fmri(shape=shape, length=length,
affine=labels_img.get_affine())
# Extract signals from maps and labels: results must be identical.
maps_signals, maps_labels = region.img_to_signals_maps(fmri_img, maps_img)
labels_signals, labels_labels =\
region.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.get_affine())
labels_signals, labels_labels =\
region.img_to_signals_labels(fmri_img, labels_img,
mask_img=mask_img)
maps_signals, maps_labels = \
region.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 = region.signals_to_img_labels(labels_signals, labels_img,
mask_img=mask_img)
assert_true(labels_img_r.shape == shape + (length,))
maps_img_r = region.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 =\
region.img_to_signals_labels(fmri_img, labels_img,
mask_img=mask_img)
assert_true(np.all(np.isnan(labels_signals[:, labels_labels.index(2)])))