def _duplicate_layer(ll: LayerList):
from copy import deepcopy
for lay in list(ll.selection):
new = deepcopy(lay)
new.name += ' copy'
ll.insert(ll.index(lay) + 1, new)
def test_layers_save_selected(tmpdir, layer_data_and_types):
"""Test saving all layer data."""
list_of_layers, _, _, filenames = layer_data_and_types
layers = LayerList(list_of_layers)
layers.selection.clear()
layers.selection.update({layers[0], layers[2]})
path = os.path.join(tmpdir, 'layers_folder')
# Check folder does not exist
assert not os.path.isdir(path)
# Write data
layers.save(path, selected=True, plugin='builtins')
# Check folder exists
assert os.path.isdir(path)
# Check only appropriate files exist
assert os.path.isfile(os.path.join(path, filenames[0]))
assert not os.path.isfile(os.path.join(path, filenames[1]))
assert os.path.isfile(os.path.join(path, filenames[2]))
assert not os.path.isfile(os.path.join(path, filenames[1]))
# Check no additional files exist
assert set(os.listdir(path)) == {filenames[0], filenames[2]}
assert set(os.listdir(tmpdir)) == {'layers_folder'}
def _convert(ll: LayerList, type_: str):
from .base.base import Layer
for lay in list(ll.selection):
idx = ll.index(lay)
data = lay.data.astype(int) if type_ == 'labels' else lay.data
ll.pop(idx)
ll.insert(idx, Layer.create(data, {'name': lay.name}, type_))
def _merge_stack(ll: LayerList, rgb=False):
selection = list(ll.selection)
for layer in selection:
ll.remove(layer)
if rgb:
new = stack_utils.merge_rgb(selection)
else:
new = stack_utils.images_to_stack(selection)
ll.append(new)
def test_adding_layer():
"""
Test adding a Layer
"""
layers = LayerList()
layer = Image(np.random.random((10, 10)))
layers.append(layer)
assert len(layers) == 1
def test_indexing():
"""
Test indexing into a LayerList
"""
layers = LayerList()
layer = Image(np.random.random((10, 10)), name='image')
layers.append(layer)
assert layers[0] == layer
assert layers['image'] == layer
def _split_stack(ll: LayerList, axis: int = 0):
layer = ll.selection.active
if not layer:
return
if layer.rgb:
images = stack_utils.split_rgb(layer)
else:
images = stack_utils.stack_to_images(layer, axis)
ll.remove(layer)
ll.extend(images)
ll.selection = set(images) # type: ignore
def test_world_extent_mixed_flipped():
"""Test world extent after adding data with a flip."""
# Flipped data results in a negative scale value which should be
# made positive when taking into consideration for the step size
# calculation
np.random.seed(0)
layers = LayerList()
layer = Image(np.random.random((15, 15)),
affine=[[0, 1, 0], [1, 0, 0], [0, 0, 1]])
layers.append(layer)
np.testing.assert_allclose(layer._data_to_world.scale, (1, -1))
np.testing.assert_allclose(layers.extent.step, (1, 1))
def test_adding_layers(qtbot):
"""
Test adding layers.
"""
layers = LayerList()
view = QtLayerList(layers)
qtbot.addWidget(view)
# Check that new layer and divider get added to vbox_layout
layer_a = Image(np.random.random((10, 10)))
layers.append(layer_a)
assert view.vbox_layout.count() == 2 * (len(layers) + 1)
assert check_layout_layers(view.vbox_layout, layers)
assert check_layout_dividers(view.vbox_layout, len(layers))
# Check that new layers and dividers get added to vbox_layout
layer_b = Image(np.random.random((15, 15)))
layer_c = Image(np.random.random((15, 15)))
layer_d = Image(np.random.random((15, 15)))
layers.append(layer_b)
layers.append(layer_c)
layers.append(layer_d)
assert view.vbox_layout.count() == 2 * (len(layers) + 1)
assert check_layout_layers(view.vbox_layout, layers)
assert check_layout_dividers(view.vbox_layout, len(layers))
def test_reordering_layers(qtbot):
"""
Test reordering layers.
"""
layers = LayerList()
view = QtLayerList(layers)
qtbot.addWidget(view)
layer_a = Image(np.random.random((10, 10)), name='image_a')
layer_b = Image(np.random.random((15, 15)), name='image_b')
layer_c = Image(np.random.random((15, 15)), name='image_c')
layer_d = Image(np.random.random((15, 15)), name='image_d')
layers.append(layer_a)
layers.append(layer_b)
layers.append(layer_c)
layers.append(layer_d)
# Check layout and layers list match after rearranging layers
layers[:] = layers[(1, 0, 3, 2)]
assert view.vbox_layout.count() == 2 * (len(layers) + 1)
assert check_layout_layers(view.vbox_layout, layers)
assert check_layout_dividers(view.vbox_layout, len(layers))
# Check layout and layers list match after swapping two layers
layers['image_b', 'image_c'] = layers['image_c', 'image_b']
assert view.vbox_layout.count() == 2 * (len(layers) + 1)
assert check_layout_layers(view.vbox_layout, layers)
assert check_layout_dividers(view.vbox_layout, len(layers))
# Check layout and layers list match after reversing list
# TEST CURRENTLY FAILING
# layers.reverse()
# assert view.vbox_layout.count() == 2 * (len(layers) + 1)
# assert check_layout_layers(view.vbox_layout, layers)
# assert check_layout_dividers(view.vbox_layout, len(layers))
# Check layout and layers list match after rearranging selected layers
layer_e = Image(np.random.random((15, 15)))
layer_f = Image(np.random.random((15, 15)))
layers.append(layer_e)
layers.append(layer_f)
for l, s in zip(layers, [False, True, False, False, True, False]):
l.selected = s
layers.move_selected(1, 2)
assert view.vbox_layout.count() == 2 * (len(layers) + 1)
assert check_layout_layers(view.vbox_layout, layers)
assert check_layout_dividers(view.vbox_layout, len(layers))
def test_empty_layers_list():
"""
Test instantiating an empty LayerList object
"""
layers = LayerList()
assert len(layers) == 0
def test_naming():
"""
Test unique naming in LayerList
"""
layers = LayerList()
layer_a = Image(np.random.random((10, 10)), name='img')
layer_b = Image(np.random.random((15, 15)), name='img')
layers.append(layer_a)
layers.append(layer_b)
assert [lay.name for lay in layers] == ['img', 'img [1]']
layer_b.name = 'chg'
assert [lay.name for lay in layers] == ['img', 'chg']
layer_a.name = 'chg'
assert [lay.name for lay in layers] == ['chg [1]', 'chg']
def test_clearing_layerlist():
"""Test clearing layer list."""
layers = LayerList()
layer = Image(np.random.random((10, 10)))
layer2 = Image(np.random.random((10, 10)))
layers.append(layer)
layers.append(layer2)
assert len(layers) == 2
layers.clear()
assert len(layers) == 0
def test_unselect_all():
"""
Test unselecting
"""
layers = LayerList()
layer_a = Image(np.random.random((10, 10)))
layer_b = Image(np.random.random((15, 15)))
layer_c = Image(np.random.random((15, 15)))
layers.append(layer_a)
layers.append(layer_b)
layers.append(layer_c)
layers.unselect_all()
assert [lay.selected for lay in layers] == [False] * 3
for lay in layers:
lay.selected = True
layers.unselect_all(ignore=layer_b)
assert [lay.selected for lay in layers] == [False, True, False]
def test_deprecated_selection():
"""Test deprecated layer selection emits warnings."""
layers = LayerList()
layer = Image(np.random.random((10, 15)))
events = []
with pytest.warns(FutureWarning):
layer.events.select.connect(lambda e: events.append(e))
layer.events.deselect.connect(lambda e: events.append(e))
layers.append(layer)
assert events[-1].type == 'select'
with pytest.warns(FutureWarning):
assert layer.selected is True
with pytest.warns(FutureWarning):
layer.selected = False
assert events[-1].type == 'deselect'
assert layer not in layers.selection
def test_get_index():
"""
Test getting indexing from LayerList
"""
layers = LayerList()
layer_a = Image(np.random.random((10, 10)), name='image_a')
layer_b = Image(np.random.random((15, 15)), name='image_b')
layers.append(layer_a)
layers.append(layer_b)
assert layers.index(layer_a) == 0
assert layers.index('image_a') == 0
assert layers.index(layer_b) == 1
assert layers.index('image_b') == 1
def test_readd_layers():
layers = LayerList()
imgs = []
for i in range(5):
img = Image(np.random.rand(10, 10, 10))
layers.append(img)
imgs.append(img)
assert layers == imgs
with pytest.raises(ValueError):
layers.append(imgs[1])
assert layers == imgs
layers[1] = layers[1]
assert layers == imgs
with pytest.raises(ValueError):
layers[1] = layers[2]
assert layers == imgs
layers[:3] = layers[:3]
assert layers == imgs
# invert a section
layers[:3] = layers[2::-1]
assert set(layers) == set(imgs)
with pytest.raises(ValueError):
layers[:3] = layers[:]
assert set(layers) == set(imgs)
def test_world_extent():
"""Test world extent after adding layers."""
np.random.seed(0)
layers = LayerList()
# Empty data is taken to be 512 x 512
np.testing.assert_allclose(layers._extent_world[0], (0, 0))
np.testing.assert_allclose(layers._extent_world[1], (511, 511))
np.testing.assert_allclose(layers._step_size, (1, 1))
# Add one layer
layer_a = Image(np.random.random((6, 10, 15)),
scale=(3, 1, 1),
translate=(10, 20, 5))
layers.append(layer_a)
np.testing.assert_allclose(layer_a._extent_world[0], (10, 20, 5))
np.testing.assert_allclose(layer_a._extent_world[1], (25, 29, 19))
np.testing.assert_allclose(layers._extent_world[0], (10, 20, 5))
np.testing.assert_allclose(layers._extent_world[1], (25, 29, 19))
np.testing.assert_allclose(layers._step_size, (3, 1, 1))
# Add another layer
layer_b = Image(np.random.random((8, 6, 15)),
scale=(6, 2, 1),
translate=(-5, -10, 10))
layers.append(layer_b)
np.testing.assert_allclose(layer_b._extent_world[0], (-5, -10, 10))
np.testing.assert_allclose(layer_b._extent_world[1], (37, 0, 24))
np.testing.assert_allclose(layers._extent_world[0], (-5, -10, 5))
np.testing.assert_allclose(layers._extent_world[1], (37, 29, 24))
np.testing.assert_allclose(layers._step_size, (3, 1, 1))
def test_world_extent():
"""Test world extent after adding layers."""
np.random.seed(0)
layers = LayerList()
# Empty data is taken to be 512 x 512
np.testing.assert_allclose(layers.extent.world[0], (-0.5, -0.5))
np.testing.assert_allclose(layers.extent.world[1], (511.5, 511.5))
np.testing.assert_allclose(layers.extent.step, (1, 1))
# Add one layer
layer_a = Image(np.random.random((6, 10, 15)),
scale=(3, 1, 1),
translate=(10, 20, 5))
layers.append(layer_a)
np.testing.assert_allclose(layer_a.extent.world[0], (8.5, 19.5, 4.5))
np.testing.assert_allclose(layer_a.extent.world[1], (26.5, 29.5, 19.5))
np.testing.assert_allclose(layers.extent.world[0], (8.5, 19.5, 4.5))
np.testing.assert_allclose(layers.extent.world[1], (26.5, 29.5, 19.5))
np.testing.assert_allclose(layers.extent.step, (3, 1, 1))
# Add another layer
layer_b = Image(np.random.random((8, 6, 15)),
scale=(6, 2, 1),
translate=(-5, -10, 10))
layers.append(layer_b)
np.testing.assert_allclose(layer_b.extent.world[0], (-8, -11, 9.5))
np.testing.assert_allclose(layer_b.extent.world[1], (40, 1, 24.5))
np.testing.assert_allclose(layers.extent.world[0], (-8, -11, 4.5))
np.testing.assert_allclose(layers.extent.world[1], (40, 29.5, 24.5))
np.testing.assert_allclose(layers.extent.step, (3, 1, 1))
def test_removing_layer():
layers = LayerList()
layer = Image(np.random.random((10, 10)))
layers.append(layer)
layers.remove(layer)
assert len(layers) == 0
def test_selection():
"""
Test only last added is selected.
"""
layers = LayerList()
layer_a = Image(np.random.random((10, 10)))
layers.append(layer_a)
assert layers[0].selected is True
layer_b = Image(np.random.random((15, 15)))
layers.append(layer_b)
assert [lay.selected for lay in layers] == [False, True]
layer_c = Image(np.random.random((15, 15)))
layers.append(layer_c)
assert [lay.selected for lay in layers] == [False] * 2 + [True]
for lay in layers:
lay.selected = True
layer_d = Image(np.random.random((15, 15)))
layers.append(layer_d)
assert [lay.selected for lay in layers] == [False] * 3 + [True]
def test_popping_layer():
"""Test popping a layer off layerlist."""
layers = LayerList()
layer = Image(np.random.random((10, 10)))
layers.append(layer)
assert len(layers) == 1
layers.pop(0)
assert len(layers) == 0
def test_layers_save(tmpdir, layer_data_and_types):
"""Test saving all layer data."""
list_of_layers, _, _, filenames = layer_data_and_types
layers = LayerList(list_of_layers)
path = os.path.join(tmpdir, 'layers_folder')
# Check folder does not exist
assert not os.path.isdir(path)
# Write data
layers.save(path, plugin='builtins')
# Check folder now exists
assert os.path.isdir(path)
# Check individual files now exist
for f in filenames:
assert os.path.isfile(os.path.join(path, f))
# Check no additional files exist
assert set(os.listdir(path)) == set(filenames)
assert set(os.listdir(tmpdir)) == set(['layers_folder'])
def test_layers_save_none_selected(tmpdir, layer_data_and_types):
"""Test saving all layer data."""
list_of_layers, _, _, filenames = layer_data_and_types
layers = LayerList(list_of_layers)
layers.selection.clear()
path = os.path.join(tmpdir, 'layers_folder')
# Check folder does not exist
assert not os.path.isdir(path)
# Write data (will get a warning that nothing is selected)
with pytest.warns(UserWarning):
layers.save(path, selected=True, plugin='builtins')
# Check folder still does not exist
assert not os.path.isdir(path)
# Check individual files still do not exist
for f in filenames:
assert not os.path.isfile(os.path.join(path, f))
# Check no additional files exist
assert set(os.listdir(tmpdir)) == set('')
def test_creating_empty_view():
"""
Test creating LayerList view.
"""
with gui_qt():
layers = LayerList()
view = QtLayerList(layers)
# Check that the layers model has been appended to the layers view
assert view.layers == layers
# Check that vbox_layout only contains one QtDivider and one spacer
assert view.vbox_layout.count() == 2
assert check_layout_layers(view.vbox_layout, layers)
assert check_layout_dividers(view.vbox_layout, 0)
def test_adding_layer():
layers = LayerList()
layer = Image(np.random.random((10, 10)))
layers.append(layer)
# LayerList should err if you add anything other than a layer
with pytest.raises(TypeError):
layers.append('something')
assert len(layers) == 1
def test_insert():
"""
Test inserting into a LayerList
"""
layers = LayerList()
layer_a = Image(np.random.random((10, 10)), name='image_a')
layer_b = Image(np.random.random((15, 15)), name='image_b')
layers.append(layer_a)
layers.insert(0, layer_b)
assert list(layers) == [layer_b, layer_a]
def layers():
"""Fixture that supplies a layers list for testing.
Returns
-------
napari.components.LayerList
The desired napari LayerList.
"""
np.random.seed(0)
list_of_layers = [
Image(np.random.rand(20, 20)),
Labels(np.random.randint(10, size=(20, 2))),
Points(np.random.rand(20, 2)),
Shapes(np.random.rand(10, 2, 2)),
Vectors(np.random.rand(10, 2, 2)),
]
return LayerList(list_of_layers)
def test_reordering():
"""
Test indexing into a LayerList by name
"""
layers = LayerList()
layer_a = Image(np.random.random((10, 10)), name='image_a')
layer_b = Image(np.random.random((15, 15)), name='image_b')
layer_c = Image(np.random.random((15, 15)), name='image_c')
layers.append(layer_a)
layers.append(layer_b)
layers.append(layer_c)
# Rearrange layers by tuple
layers[:] = [layers[i] for i in (1, 0, 2)]
assert list(layers) == [layer_b, layer_a, layer_c]
# Reverse layers
layers.reverse()
assert list(layers) == [layer_c, layer_a, layer_b]
def test_ndim():
"""Test world extent after adding layers."""
np.random.seed(0)
layers = LayerList()
assert layers.ndim == 2
# Add one layer
layer_a = Image(np.random.random((10, 15)))
layers.append(layer_a)
assert layers.ndim == 2
# Add another layer
layer_b = Image(np.random.random((8, 6, 15)))
layers.append(layer_b)
assert layers.ndim == 3
# Remove layer
layers.remove(layer_b)
assert layers.ndim == 2
