def test_get_value_3d_nd(
ray_start, ray_direction, expected_value, expected_index
):
vertices = np.array(
[
[0, 3, 0, 0],
[0, 3, 0, 3],
[0, 3, 3, 0],
[0, 5, 0, 0],
[0, 5, 0, 3],
[0, 5, 3, 0],
[0, 2, 50, 50],
[0, 2, 50, 100],
[0, 2, 100, 50],
]
)
faces = np.array([[0, 1, 2], [3, 4, 5], [6, 7, 8]])
values = np.array([1, 2, 3, 1, 2, 3, 1, 2, 3])
surface_layer = Surface((vertices, faces, values))
surface_layer._slice_dims([0, 0, 0, 0], ndisplay=3)
value, index = surface_layer.get_value(
position=ray_start,
view_direction=ray_direction,
dims_displayed=[1, 2, 3],
world=False,
)
assert index == expected_index
np.testing.assert_allclose(value, expected_value)
def setup(self, n):
np.random.seed(0)
self.data = (
np.random.random((n, 3)),
np.random.randint(n, size=(n, 3)),
np.random.random(n),
)
self.layer = Surface(self.data)
def test_random_4D_surface():
"""Test instantiating Surface layer with random 4D data."""
np.random.seed(0)
vertices = np.random.random((10, 4))
faces = np.random.randint(10, size=(6, 3))
values = np.random.random(10)
data = (vertices, faces, values)
layer = Surface(data)
assert layer.ndim == 4
assert np.all([np.all(ld == d) for ld, d in zip(layer.data, data)])
assert layer._data_view.shape[1] == 2
assert layer._view_vertex_values.ndim == 1
layer._slice_dims(ndisplay=3)
assert layer._data_view.shape[1] == 3
assert layer._view_vertex_values.ndim == 1
def test_shading():
"""Test setting shading"""
np.random.seed(0)
vertices = np.random.random((10, 3))
faces = np.random.randint(10, size=(6, 3))
values = np.random.random(10)
data = (vertices, faces, values)
layer = Surface(data)
# change shading property
shading = 'flat'
layer.shading = shading
assert layer.shading == shading
# set shading as keyword argument
layer = Surface(data, shading=shading)
assert layer.shading == shading
def test_world_data_extent():
"""Test extent after applying transforms."""
data = [(-5, 0), (0, 15), (30, 12)]
min_val = (-5, 0)
max_val = (30, 15)
layer = Surface((np.array(data), np.array((0, 1, 2)), np.array((0, 0, 0))))
extent = np.array((min_val, max_val))
check_layer_world_data_extent(layer, extent, (3, 1), (20, 5))
def test_surface_gamma():
"""Test setting gamma."""
np.random.seed(0)
vertices = np.random.random((10, 3))
faces = np.random.randint(10, size=(6, 3))
values = np.random.random(10)
data = (vertices, faces, values)
layer = Surface(data)
assert layer.gamma == 1
# Change gamma property
gamma = 0.7
layer.gamma = gamma
assert layer.gamma == gamma
# Set gamma as keyword argument
layer = Surface(data, gamma=gamma)
assert layer.gamma == gamma
def test_random_3D_multitimeseries_surface():
"""Test instantiating Surface layer with random 3D multitimeseries data."""
np.random.seed(0)
vertices = np.random.random((10, 3))
faces = np.random.randint(10, size=(6, 3))
values = np.random.random((16, 22, 10))
data = (vertices, faces, values)
layer = Surface(data)
assert layer.ndim == 5
assert np.all([np.all(ld == d) for ld, d in zip(layer.data, data)])
assert layer._data_view.shape[1] == 2
assert layer._view_vertex_values.ndim == 1
assert layer.extent.data[1][0] == 16
assert layer.extent.data[1][1] == 22
layer._slice_dims(ndisplay=3)
assert layer._data_view.shape[1] == 3
assert layer._view_vertex_values.ndim == 1
def _make_surface_layer(self,
vertices,
faces,
name,
values=None,
**kwargs):
if values is None:
values = np.ones(vertices.shape[0])
data = (vertices, faces, values)
layer = Surface(data, name=name, **kwargs)
self._init_layer(layer)
def test_random_surface():
"""Test instantiating Surface layer with random 2D data."""
np.random.seed(0)
vertices = np.random.random((10, 2))
faces = np.random.randint(10, size=(6, 3))
values = np.random.random(10)
data = (vertices, faces, values)
layer = Surface(data)
assert np.all([np.all(ld == d) for ld, d in zip(layer.data, data)])
assert np.all(layer.vertices == vertices)
assert np.all(layer.faces == faces)
assert np.all(layer.vertex_values == values)
assert layer._data_view.shape[1] == 2
def test_changing_surface():
"""Test changing surface layer data"""
np.random.seed(0)
vertices = np.random.random((10, 2))
faces = np.random.randint(10, size=(6, 3))
values = np.random.random(10)
data = (vertices, faces, values)
layer = Surface(data)
vertices = np.random.random((10, 3))
faces = np.random.randint(10, size=(6, 3))
values = np.random.random(10)
data = (vertices, faces, values)
layer.data = data
assert layer.ndim == 3
assert np.all([np.all(ld == d) for ld, d in zip(layer.data, data)])
assert layer._data_view.shape[1] == 2
assert layer._view_vertex_values.ndim == 1
layer._slice_dims(ndisplay=3)
assert layer._data_view.shape[1] == 3
assert layer._view_vertex_values.ndim == 1
def test_random_surface_no_values():
"""Test instantiating Surface layer with random 2D data but no vertex values."""
np.random.seed(0)
vertices = np.random.random((10, 2))
faces = np.random.randint(10, size=(6, 3))
data = (vertices, faces)
layer = Surface(data)
assert layer.ndim == 2
assert np.all([np.all(ld == d) for ld, d in zip(layer.data, data)])
assert np.all(layer.vertices == vertices)
assert np.all(layer.faces == faces)
assert np.all(layer.vertex_values == np.ones(len(vertices)))
assert layer._data_view.shape[1] == 2
assert layer._view_vertex_values.ndim == 1
class Surface2DSuite:
"""Benchmarks for the Surface layer with 2D data"""
params = [2**i for i in range(4, 18, 2)]
def setup(self, n):
np.random.seed(0)
self.data = (
np.random.random((n, 2)),
np.random.randint(n, size=(n, 3)),
np.random.random(n),
)
self.layer = Surface(self.data)
def time_create_layer(self, n):
"""Time to create an image layer."""
Surface(self.data)
def time_refresh(self, n):
"""Time to refresh view."""
self.layer.refresh()
def time_set_view_slice(self, n):
"""Time to set view slice."""
self.layer._set_view_slice()
def time_update_thumbnail(self, n):
"""Time to update thumbnail."""
self.layer._update_thumbnail()
def time_get_value(self, n):
"""Time to get current value."""
self.layer.get_value((0, ) * 2)
def mem_layer(self, n):
"""Memory used by layer."""
return self.layer
def mem_data(self, n):
"""Memory used by raw data."""
return self.data
def test_random_3D_timeseries_surface():
"""Test instantiating Surface layer with random 3D timeseries data."""
np.random.seed(0)
vertices = np.random.random((10, 3))
faces = np.random.randint(10, size=(6, 3))
values = np.random.random((22, 10))
data = (vertices, faces, values)
layer = Surface(data)
assert layer.ndim == 4
assert np.all([np.all(ld == d) for ld, d in zip(layer.data, data)])
assert layer._data_view.shape[1] == 2
assert layer._view_vertex_values.ndim == 1
assert layer.shape[0] == 22
layer.dims.ndisplay = 3
assert layer._data_view.shape[1] == 3
assert layer._view_vertex_values.ndim == 1
# If a values axis is made to be a displayed axis then no data should be
# shown
layer.dims.order = [3, 0, 1, 2]
assert len(layer._data_view) == 0
def test_visiblity():
"""Test setting layer visibility."""
np.random.seed(0)
vertices = np.random.random((10, 3))
faces = np.random.randint(10, size=(6, 3))
values = np.random.random(10)
data = (vertices, faces, values)
layer = Surface(data)
assert layer.visible is True
layer.visible = False
assert layer.visible is False
layer = Surface(data, visible=False)
assert layer.visible is False
layer.visible = True
assert layer.visible is True
from napari._qt.layers.qt_image_base_layer import (
QtBaseImageControls,
create_range_popup,
)
from napari.layers import Image, Surface
_IMAGE = np.arange(100).astype(np.uint16).reshape((10, 10))
_SURF = (
np.random.random((10, 2)),
np.random.randint(10, size=(6, 3)),
np.arange(100).astype(np.float),
)
@pytest.mark.parametrize('layer', [Image(_IMAGE), Surface(_SURF)])
def test_base_controls_creation(qtbot, layer):
"""Check basic creation of QtBaseImageControls works"""
qtctrl = QtBaseImageControls(layer)
qtbot.addWidget(qtctrl)
original_clims = tuple(layer.contrast_limits)
slider_clims = qtctrl.contrastLimitsSlider.values()
assert slider_clims[0] == 0
assert slider_clims[1] == 99
assert tuple(slider_clims) == original_clims
@pytest.mark.parametrize('layer', [Image(_IMAGE), Surface(_SURF)])
def test_clim_right_click_shows_popup(qtbot, layer):
"""Right clicking on the contrast limits slider should show a popup."""
qtctrl = QtBaseImageControls(layer)
def time_create_layer(self, n):
"""Time to create a layer."""
Surface(self.data)
QContrastLimitsPopup,
QRangeSliderPopup,
QtBaseImageControls,
range_to_decimals,
)
from napari.layers import Image, Surface
_IMAGE = np.arange(100).astype(np.uint16).reshape((10, 10))
_SURF = (
np.random.random((10, 2)),
np.random.randint(10, size=(6, 3)),
np.arange(100).astype(float),
)
@pytest.mark.parametrize('layer', [Image(_IMAGE), Surface(_SURF)])
def test_base_controls_creation(qtbot, layer):
"""Check basic creation of QtBaseImageControls works"""
qtctrl = QtBaseImageControls(layer)
qtbot.addWidget(qtctrl)
original_clims = tuple(layer.contrast_limits)
slider_clims = qtctrl.contrastLimitsSlider.value()
assert slider_clims[0] == 0
assert slider_clims[1] == 99
assert tuple(slider_clims) == original_clims
@patch.object(QRangeSliderPopup, 'show')
@pytest.mark.parametrize('layer', [Image(_IMAGE), Surface(_SURF)])
def test_clim_right_click_shows_popup(mock_show, qtbot, layer):
"""Right clicking on the contrast limits slider should show a popup."""
def time_create_layer(self, n):
"""Time to create an image layer."""
layer = Surface(self.data)
