Пример #1
0
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)
Пример #2
0
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)
Пример #3
0
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)])))
Пример #4
0
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)])))