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_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 test_removing_layers(qtbot):
"""
Test removing layers.
"""
layers = LayerList()
view = QtLayerList(layers)
qtbot.addWidget(view)
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)
# Check layout and layers list match after removing a layer
layers.remove(layer_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 removing a layer
layers.remove(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))
layers.append(layer_b)
layers.append(layer_d)
# Select first and third layers
for layer, s in zip(layers, [True, True, False, False]):
layer.selected = s
layers.remove_selected()
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_move_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)
layers.append(layer_d)
# Check nothing moves if given same insert and origin
layers.unselect_all()
layers.move_selected(2, 2)
assert list(layers) == [layer_a, layer_b, layer_c, layer_d]
assert [lay.selected for lay in layers] == [False, False, True, False]
# Move middle element to front of list and back
layers.unselect_all()
layers.move_selected(2, 0)
assert list(layers) == [layer_c, layer_a, layer_b, layer_d]
assert [lay.selected for lay in layers] == [True, False, False, False]
layers.unselect_all()
layers.move_selected(0, 2)
assert list(layers) == [layer_a, layer_b, layer_c, layer_d]
assert [lay.selected for lay in layers] == [False, False, True, False]
# Move middle element to end of list and back
layers.unselect_all()
layers.move_selected(2, 3)
assert list(layers) == [layer_a, layer_b, layer_d, layer_c]
assert [lay.selected for lay in layers] == [False, False, False, True]
layers.unselect_all()
layers.move_selected(3, 2)
assert list(layers) == [layer_a, layer_b, layer_c, layer_d]
assert [lay.selected for lay in layers] == [False, False, True, False]
# Select first two layers only
for layer, s in zip(layers, [True, True, False, False]):
layer.selected = s
# Move unselected middle element to front of list even if others selected
layers.move_selected(2, 0)
assert list(layers) == [layer_c, layer_a, layer_b, layer_d]
# Move selected first element back to middle of list
layers.move_selected(0, 2)
assert list(layers) == [layer_a, layer_b, layer_c, layer_d]
# Select first two layers only
for layer, s in zip(layers, [True, True, False, False]):
layer.selected = s
# Check nothing moves if given same insert and origin and multiple selected
layers.move_selected(0, 0)
assert list(layers) == [layer_a, layer_b, layer_c, layer_d]
assert [lay.selected for lay in layers] == [True, True, False, False]
# Check nothing moves if given same insert and origin and multiple selected
layers.move_selected(1, 1)
assert list(layers) == [layer_a, layer_b, layer_c, layer_d]
assert [lay.selected for lay in layers] == [True, True, False, False]
# Move first two selected to middle of list
layers.move_selected(0, 1)
assert list(layers) == [layer_c, layer_a, layer_b, layer_d]
assert [lay.selected for lay in layers] == [False, True, True, False]
# Move middle selected to front of list
layers.move_selected(2, 0)
assert list(layers) == [layer_a, layer_b, layer_c, layer_d]
assert [lay.selected for lay in layers] == [True, True, False, False]
# Move first two selected to middle of list
layers.move_selected(1, 2)
assert list(layers) == [layer_c, layer_a, layer_b, layer_d]
assert [lay.selected for lay in layers] == [False, True, True, False]
# Move middle selected to front of list
layers.move_selected(1, 0)
assert list(layers) == [layer_a, layer_b, layer_c, layer_d]
assert [lay.selected for lay in layers] == [True, True, False, False]
# Select first and third layers only
for layer, s in zip(layers, [True, False, True, False]):
layer.selected = s
# Move selection together to middle
layers.move_selected(2, 2)
assert list(layers) == [layer_b, layer_a, layer_c, layer_d]
assert [lay.selected for lay in layers] == [False, True, True, False]
layers[:] = layers[(1, 0, 2, 3)]
# Move selection together to middle
layers.move_selected(0, 1)
assert list(layers) == [layer_b, layer_a, layer_c, layer_d]
assert [lay.selected for lay in layers] == [False, True, True, False]
layers[:] = layers[(1, 0, 2, 3)]
# Move selection together to end
layers.move_selected(2, 3)
assert list(layers) == [layer_b, layer_d, layer_a, layer_c]
assert [lay.selected for lay in layers] == [False, False, True, True]
layers[:] = layers[(2, 0, 3, 1)]
# Move selection together to end
layers.move_selected(0, 2)
assert list(layers) == [layer_b, layer_d, layer_a, layer_c]
assert [lay.selected for lay in layers] == [False, False, True, True]
layers[:] = layers[(2, 0, 3, 1)]
# Move selection together to end
layers.move_selected(0, 3)
assert list(layers) == [layer_b, layer_d, layer_a, layer_c]
assert [lay.selected for lay in layers] == [False, False, True, True]
layers[:] = layers[(2, 0, 3, 1)]
layer_e = Image(np.random.random((15, 15)))
layer_f = Image(np.random.random((15, 15)))
layers.append(layer_e)
layers.append(layer_f)
# Check current order is correct
assert list(layers) == [
layer_a,
layer_b,
layer_c,
layer_d,
layer_e,
layer_f,
]
# Select second and firth layers only
for layer, s in zip(layers, [False, True, False, False, True, False]):
layer.selected = s
# Move selection together to middle
layers.move_selected(1, 2)
assert list(layers) == [
layer_a,
layer_c,
layer_b,
layer_e,
layer_d,
layer_f,
]
assert [lay.selected for lay in layers] == [
False,
False,
True,
True,
False,
False,
]
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]
# check that the next to last layer is now selected
assert [lay.selected for lay in layers] == [False, True]
layers.remove_selected()
assert list(layers) == [layer_a]
assert [lay.selected for lay in layers] == [True]
# select and remove first layer only
layers.append(layer_b)
layers.append(layer_c)
assert list(layers) == [layer_a, layer_b, layer_c]
layer_a.selected = True
layer_b.selected = False
layer_c.selected = False
layers.remove_selected()
assert list(layers) == [layer_b, layer_c]
assert [lay.selected for lay in layers] == [True, False]
# select and remove first and last layer of four
layers.append(layer_a)
layers.append(layer_d)
assert list(layers) == [layer_b, layer_c, layer_a, layer_d]
layer_a.selected = False
layer_b.selected = True
layer_c.selected = False
layer_d.selected = True
layers.remove_selected()
assert list(layers) == [layer_c, layer_a]
assert [lay.selected for lay in layers] == [True, False]
# 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_c.selected = False
layer_d.selected = False
layers.remove_selected()
assert list(layers) == [layer_c, layer_d]
assert [lay.selected for lay in layers] == [True, False]
# select and remove all layersay
for lay in layers:
lay.selected = True
layers.remove_selected()
assert len(layers) == 0
def test_name_uniqueness():
layers = LayerList()
layers.append(Image(np.random.random((10, 15)), name="Image [1]"))
layers.append(Image(np.random.random((10, 15)), name="Image"))
layers.append(Image(np.random.random((10, 15)), name="Image"))
assert [x.name for x in layers] == ['Image [1]', 'Image', 'Image [2]']
def test_move_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)
layers.append(layer_d)
# Check nothing moves if given same insert and origin
layers.selection.clear()
layers.move_selected(2, 2)
assert list(layers) == [layer_a, layer_b, layer_c, layer_d]
assert layers.selection == {layer_c}
# Move middle element to front of list and back
layers.selection.clear()
layers.move_selected(2, 0)
assert list(layers) == [layer_c, layer_a, layer_b, layer_d]
assert layers.selection == {layer_c}
layers.selection.clear()
layers.move_selected(0, 2)
assert list(layers) == [layer_a, layer_b, layer_c, layer_d]
assert layers.selection == {layer_c}
# Move middle element to end of list and back
layers.selection.clear()
layers.move_selected(2, 3)
assert list(layers) == [layer_a, layer_b, layer_d, layer_c]
assert layers.selection == {layer_c}
layers.selection.clear()
layers.move_selected(3, 2)
assert list(layers) == [layer_a, layer_b, layer_c, layer_d]
assert layers.selection == {layer_c}
# Select first two layers only
layers.selection = layers[:2]
# Move unselected middle element to front of list even if others selected
layers.move_selected(2, 0)
assert list(layers) == [layer_c, layer_a, layer_b, layer_d]
# Move selected first element back to middle of list
layers.move_selected(0, 2)
assert list(layers) == [layer_a, layer_b, layer_c, layer_d]
# Select first two layers only
layers.selection = layers[:2]
# Check nothing moves if given same insert and origin and multiple selected
layers.move_selected(0, 0)
assert list(layers) == [layer_a, layer_b, layer_c, layer_d]
assert layers.selection == {layer_a, layer_b}
# Check nothing moves if given same insert and origin and multiple selected
layers.move_selected(1, 1)
assert list(layers) == [layer_a, layer_b, layer_c, layer_d]
assert layers.selection == {layer_a, layer_b}
# Move first two selected to middle of list
layers.move_selected(0, 2)
assert list(layers) == [layer_c, layer_a, layer_b, layer_d]
assert layers.selection == {layer_a, layer_b}
# Move middle selected to front of list
layers.move_selected(2, 0)
assert list(layers) == [layer_a, layer_b, layer_c, layer_d]
assert layers.selection == {layer_a, layer_b}
# Move first two selected to middle of list
layers.move_selected(1, 2)
assert list(layers) == [layer_c, layer_a, layer_b, layer_d]
assert layers.selection == {layer_a, layer_b}
# Move middle selected to front of list
layers.move_selected(1, 0)
assert list(layers) == [layer_a, layer_b, layer_c, layer_d]
assert layers.selection == {layer_a, layer_b}
# Select first and third layers only
layers.selection = layers[::2]
# Move selection together to middle
layers.move_selected(2, 2)
assert list(layers) == [layer_b, layer_a, layer_c, layer_d]
assert layers.selection == {layer_a, layer_c}
layers.move_multiple((1, 0, 2, 3), 0)
# Move selection together to middle
layers.move_selected(0, 1)
assert list(layers) == [layer_b, layer_a, layer_c, layer_d]
assert layers.selection == {layer_a, layer_c}
layers.move_multiple((1, 0, 2, 3), 0)
# Move selection together to end
layers.move_selected(2, 3)
assert list(layers) == [layer_b, layer_d, layer_a, layer_c]
assert layers.selection == {layer_a, layer_c}
layers.move_multiple((2, 0, 3, 1), 0)
# Move selection together to end
layers.move_selected(0, 3)
assert list(layers) == [layer_b, layer_d, layer_a, layer_c]
assert layers.selection == {layer_a, layer_c}
layers.move_multiple((2, 0, 3, 1), 0)
layer_e = Image(np.random.random((15, 15)))
layer_f = Image(np.random.random((15, 15)))
layers.append(layer_e)
layers.append(layer_f)
# Check current order is correct
assert list(layers) == [
layer_a,
layer_b,
layer_c,
layer_d,
layer_e,
layer_f,
]
# Select second and firth layers only
layers.selection = {layers[1], layers[4]}
# Move selection together to middle
layers.move_selected(1, 2)
assert list(layers) == [
layer_a,
layer_c,
layer_b,
layer_e,
layer_d,
layer_f,
]
assert layers.selection == {layer_b, layer_e}