def test_point_variable_step_size():
dims = Dims(ndim=3)
assert dims.point == (0, ) * 3
desired_range = ((0, 6, 0.5), (0, 6, 1), (0, 6, 2))
dims.set_range(range(3), desired_range)
assert dims.range == desired_range
# set point updates current_step indirectly
dims.set_point([0, 1, 2], (2.9, 2.9, 2.9))
assert dims.current_step == (6, 3, 1)
# point is a property computed on demand from current_step
assert dims.point == (3, 3, 2)
# can set step directly as well
# note that out of range values get clipped
dims.set_current_step((0, 1, 2), (1, -3, 5))
assert dims.current_step == (1, 0, 2)
assert dims.point == (0.5, 0, 4)
dims.set_current_step(0, -1)
assert dims.current_step == (0, 0, 2)
assert dims.point == (0, 0, 4)
# mismatched len(axis) vs. len(value)
with pytest.raises(ValueError):
dims.set_point((0, 1), (0, 0, 0))
with pytest.raises(ValueError):
dims.set_current_step((0, 1), (0, 0, 0))
def test_singleton_dims(qtbot):
"""
Test singleton dims causes no slider.
"""
ndim = 4
dims = Dims(ndim)
dims.set_range(0, (0, 1, 1))
view = QtDims(dims)
qtbot.addWidget(view)
# Check that the dims model has been appended to the dims view
assert view.dims == dims
# Check the number of displayed sliders is only one
assert view.nsliders == 4
assert np.sum(view._displayed_sliders) == 1
assert np.all([
s.isVisibleTo(view) == d
for s, d in zip(view.slider_widgets, view._displayed_sliders)
])
# Change ndisplay to three
view.dims.ndisplay = 3
# Check no sliders now shown
assert np.sum(view._displayed_sliders) == 0
# Change ndisplay back to two
view.dims.ndisplay = 2
# Check only slider now shown
assert np.sum(view._displayed_sliders) == 1
def test_range_set_multiple():
"""
Tests bulk range setting.
"""
dims = Dims(ndim=4)
assert dims.range == ((0, 2, 1), ) * 4
dims.set_range((0, 3), [(0, 6, 3), (0, 9, 3)])
assert dims.range == ((0, 6, 3), ) + ((0, 2, 1), ) * 2 + ((0, 9, 3), )
# last_used will be set to the smallest axis in range
dims.set_range(range(1, 4), ((0, 5, 1), ) * 3)
assert dims.range == ((0, 6, 3), ) + ((0, 5, 1), ) * 3
# test with descending axis order
dims.set_range(axis=(3, 0), _range=[(0, 4, 1), (0, 6, 1)])
assert dims.range == ((0, 6, 1), ) + ((0, 5, 1), ) * 2 + ((0, 4, 1), )
# out of range axis raises a ValueError
with pytest.raises(ValueError):
dims.set_range((dims.ndim, 0), [(0.0, 4.0, 1.0)] * 2)
# sequence lengths for axis and _range do not match
with pytest.raises(ValueError):
dims.set_range((0, 1), [(0.0, 4.0, 1.0)] * 3)
def test_range():
"""
Tests range setting.
"""
dims = Dims(ndim=4)
assert dims.range == ((0, 2, 1), ) * 4
dims.set_range(3, (0, 4, 2))
assert dims.range == ((0, 2, 1), ) * 3 + ((0, 4, 2), )
def test_range():
"""
Tests range setting.
"""
dims = Dims(4)
assert dims.range == [(0, 2, 1)] * 4
dims.set_range(3, (0, 4, 2))
assert dims.range == [(0, 2, 1)] * 3 + [(0, 4, 2)]
def test_roll():
"""Test basic roll behavior."""
dims = Dims(ndim=4)
dims.set_range(0, (0, 10, 1))
dims.set_range(1, (0, 10, 1))
dims.set_range(2, (0, 10, 1))
dims.set_range(3, (0, 10, 1))
assert dims.order == (0, 1, 2, 3)
dims._roll()
assert dims.order == (3, 0, 1, 2)
dims._roll()
assert dims.order == (2, 3, 0, 1)
def test_point():
"""
Test point setting.
"""
dims = Dims(ndim=4)
assert dims.point == (0, ) * 4
dims.set_range(3, (0, 5, 1))
dims.set_point(3, 4)
assert dims.point == (0, 0, 0, 4)
dims.set_range(2, (0, 5, 1))
dims.set_point(2, 1)
assert dims.point == (0, 0, 1, 4)
def test_point():
"""
Test point setting.
"""
dims = Dims(ndim=4)
assert dims.point == (0, ) * 4
dims.set_range(range(dims.ndim), ((0, 5, 1), ) * dims.ndim)
dims.set_point(3, 4)
assert dims.point == (0, 0, 0, 4)
dims.set_point(2, 1)
assert dims.point == (0, 0, 1, 4)
dims.set_point((0, 1, 2), (2.1, 2.6, 0.0))
assert dims.point == (2, 3, 0, 4)
def test_roll_skip_dummy_axis_3():
"""Test basic roll skips all axes with length 1."""
dims = Dims(ndim=4)
dims.set_range(0, (0, 10, 1))
dims.set_range(1, (0, 0, 1))
dims.set_range(2, (0, 10, 1))
dims.set_range(3, (0, 0, 1))
assert dims.order == (0, 1, 2, 3)
dims._roll()
assert dims.order == (2, 1, 0, 3)
dims._roll()
assert dims.order == (0, 1, 2, 3)
def test_slice_labels(qtbot):
ndim = 4
dims = Dims(ndim=ndim)
dims.set_range(0, (0, 20, 1))
view = QtDims(dims)
qtbot.addWidget(view)
# make sure the totslice_label is showing the correct number
assert int(view.slider_widgets[0].totslice_label.text()) == 19
# make sure setting the dims.point updates the slice label
label_edit = view.slider_widgets[0].curslice_label
dims.set_point(0, 15)
assert int(label_edit.text()) == 15
# make sure setting the current slice label updates the model
label_edit.setText(str(8))
label_edit.editingFinished.emit()
assert dims.point[0] == 8
def test_indices():
"""
Test indices values.
"""
dims = Dims(4)
# On instantiation the last two dims are set to sliced mode
assert dims.indices == (0, ) * 2 + (slice(None, None, None), ) * 2
# Set the values of the first two dims in point mode outside of range
dims.set_point(0, 2)
dims.set_point(1, 3)
assert dims.indices == (1, 1) + (slice(None, None, None), ) * 2
# Increase range and then set points again
# Note changing the step size changes the indices for the same point value
dims.set_range(0, (0, 4, 2))
dims.set_range(1, (0, 4, 2))
dims.set_point(0, 2)
dims.set_point(1, 3)
assert dims.indices == (1, 2) + (slice(None, None, None), ) * 2
def test_order_when_changing_ndim():
"""
Test order of the dims when changing the number of dimensions.
"""
dims = Dims(ndim=4)
dims.set_range(0, (0, 4, 1))
dims.set_point(0, 2)
dims.ndim = 5
# Test that new dims get appended to the beginning of lists
assert dims.point == (0, 2, 0, 0, 0)
assert dims.order == (0, 1, 2, 3, 4)
assert dims.axis_labels == ('0', '1', '2', '3', '4')
dims.set_range(2, (0, 4, 1))
dims.set_point(2, 3)
dims.ndim = 3
# Test that dims get removed from the beginning of lists
assert dims.point == (3, 0, 0)
assert dims.order == (0, 1, 2)
assert dims.axis_labels == ('2', '3', '4')
def make_worker(qtbot,
nframes=8,
fps=20,
frame_range=None,
loop_mode=LoopMode.LOOP):
# sets up an AnimationWorker ready for testing, and breaks down when done
dims = Dims(ndim=4)
qtdims = QtDims(dims)
qtbot.addWidget(qtdims)
nz = 8
max_index = nz - 1
step = 1
dims.set_range(0, (0, max_index, step))
slider_widget = qtdims.slider_widgets[0]
slider_widget.loop_mode = loop_mode
slider_widget.fps = fps
slider_widget.frame_range = frame_range
worker = AnimationWorker(slider_widget)
worker._count = 0
worker.nz = nz
def bump(*args):
if worker._count < nframes:
worker._count += 1
else:
worker.finish()
def count_reached():
assert worker._count >= nframes
def go():
worker.work()
qtbot.waitUntil(count_reached, timeout=6000)
return worker.current
worker.frame_requested.connect(bump)
worker.go = go
yield worker
def test_roll_skip_dummy_axis_2():
"""Test basic roll skips axis with length 1 when not first."""
dims = Dims(ndim=4)
dims.set_range(0, (0, 10, 1))
dims.set_range(1, (0, 0, 1))
dims.set_range(2, (0, 10, 1))
dims.set_range(3, (0, 10, 1))
assert dims.order == (0, 1, 2, 3)
dims._roll()
assert dims.order == (3, 1, 0, 2)
dims._roll()
assert dims.order == (2, 1, 3, 0)
def test_roll_skip_dummy_axis_1():
"""Test basic roll skips axis with length 1."""
dims = Dims(ndim=4)
dims.set_range(0, (0, 1, 1))
dims.set_range(1, (0, 10, 1))
dims.set_range(2, (0, 10, 1))
dims.set_range(3, (0, 10, 1))
assert dims.order == [0, 1, 2, 3]
dims._roll()
assert dims.order == [0, 3, 1, 2]
dims._roll()
assert dims.order == [0, 2, 3, 1]
