def test_layers_save_seleteced(tmpdir, layer_data_and_types):
"""Test saving all layer data."""
list_of_layers, _, _, filenames = layer_data_and_types
layers = LayerList(list_of_layers)
layers.unselect_all()
layers[0].selected = True
layers[2].selected = True
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)) == set([filenames[0], filenames[2]])
assert set(os.listdir(tmpdir)) == set(['layers_folder'])
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_toggle_visibility():
"""
Test toggling layer visibility
"""
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)))
layer_d = Image(np.random.random((15, 15)))
layers.append(layer_a)
layers.append(layer_b)
layers.append(layer_c)
layers.append(layer_d)
layers[0].visible = False
layers[1].visible = True
layers[2].visible = False
layers[3].visible = True
layers.select_all()
layers[0].selected = False
layers.toggle_selected_visibility()
assert [lay.visible for lay in layers] == [False, False, True, False]
layers.toggle_selected_visibility()
assert [lay.visible for lay in layers] == [False, True, False, True]
def test_empty_layers_list():
"""
Test instantiating an empty LayerList object
"""
layers = LayerList()
assert len(layers) == 0
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 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], (512, 512))
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], (28, 30, 20))
np.testing.assert_allclose(layers._extent_world[0], (10, 20, 5))
np.testing.assert_allclose(layers._extent_world[1], (28, 30, 20))
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], (43, 2, 25))
np.testing.assert_allclose(layers._extent_world[0], (-5, -10, 5))
np.testing.assert_allclose(layers._extent_world[1], (43, 30, 25))
np.testing.assert_allclose(layers._step_size, (3, 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_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_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 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_clearing_layerlist():
"""Test clearing layer list."""
layers = LayerList()
layer = Image(np.random.random((10, 10)))
layers.append(layer)
layers.append(layer)
assert len(layers) == 2
layers.clear()
assert len(layers) == 0
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 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_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_remove_selected():
"""
Test removing selected layers
"""
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)))
layer_d = Image(np.random.random((15, 15)))
layers.append(layer_a)
layers.append(layer_b)
layers.append(layer_c)
# remove last added layer as only one selected
layers.remove_selected()
assert list(layers) == [layer_a, layer_b]
# remove no layers as none selected
layers.remove_selected()
assert list(layers) == [layer_a, layer_b]
# select and remove first layer only
layers.append(layer_c)
layer_c.selected = False
layer_a.selected = True
layers.remove_selected()
assert list(layers) == [layer_b, layer_c]
# select and remove first and last layer of four
layers.append(layer_a)
layers.append(layer_d)
layer_b.selected = True
layers.remove_selected()
assert list(layers) == [layer_c, layer_a]
# select and remove middle two layers of four
layers.append(layer_b)
layers.append(layer_d)
layer_a.selected = True
layer_b.selected = True
layer_d.selected = False
layers.remove_selected()
assert list(layers) == [layer_c, layer_d]
# select and remove all layers
for l in layers:
l.selected = True
layers.remove_selected()
assert len(layers) == 0
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_world_extent_mixed_ndim():
"""Test world extent after adding layers of different dimensionality."""
np.random.seed(0)
layers = LayerList()
# Add 3D layer
layer_a = Image(np.random.random((15, 15, 15)), scale=(4, 12, 2))
layers.append(layer_a)
np.testing.assert_allclose(layers._extent_world[1], (56, 168, 28))
# Add 2D layer
layer_b = Image(np.random.random((10, 10)), scale=(6, 4))
layers.append(layer_b)
np.testing.assert_allclose(layers._extent_world[1], (56, 168, 36))
np.testing.assert_allclose(layers._step_size, (4, 6, 2))
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[i] for i in (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))
# Do another reorder and check layout and layers list match
# after swapping layers again
layers[:] = [layers[i] for i in (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 reversing list
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 layer, s in zip(layers, [False, True, False, False, True, False]):
layer.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_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 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_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(qtbot):
"""Test clearing layer list."""
layers = LayerList()
view = QtLayerList(layers)
qtbot.addWidget(view)
layers.extend([Image(np.random.random((15, 15))) for _ in range(4)])
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))
layers.clear()
assert len(layers) == 0
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_world_extent_mixed_ndim():
"""Test world extent after adding layers of different dimensionality."""
np.random.seed(0)
layers = LayerList()
# Add 3D layer
layer_a = Image(np.random.random((15, 15, 15)), scale=(4, 12, 2))
layers.append(layer_a)
np.testing.assert_allclose(layers.extent.world[1], (58, 174, 29))
np.testing.assert_allclose(layers.extent.world[1] - layers.extent.world[0],
(60, 180, 30))
# Add 2D layer
layer_b = Image(np.random.random((10, 10)), scale=(6, 4))
layers.append(layer_b)
np.testing.assert_allclose(layers.extent.world[1], (58, 174, 38))
np.testing.assert_allclose(layers.extent.world[1] - layers.extent.world[0],
(60, 180, 40))
np.testing.assert_allclose(layers.extent.step, (4, 6, 2))
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_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
def test_remove_selected():
"""Test removing selected layers."""
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)
# remove last added layer as only one selected
layers.selection.clear()
layers.selection.add(layer_c)
layers.remove_selected()
assert list(layers) == [layer_a, layer_b]
# select and remove all layersay
layers.select_all()
layers.remove_selected()
assert len(layers) == 0
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_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]
