vispy 0.15.0__cp313-cp313-macosx_11_0_arm64.whl

vispy/visuals/tests/test_scalable_textures.py

@@ -0,0 +1,196 @@
+import numpy as np
+import pytest
+
+from vispy.testing import run_tests_if_main
+
+from vispy.visuals._scalable_textures import (
+    get_default_clim_from_dtype,
+    get_default_clim_from_data,
+    CPUScaledTextureMixin,
+    GPUScaledTextureMixin,
+)
+
+
+class Stub:
+    _ndim = 2
+
+    def __init__(self, data, **kwargs):
+        pass
+
+    def set_data(self, data, *args, **kwargs):
+        self._data = data
+
+
+class CPUScaledStub(CPUScaledTextureMixin, Stub):
+    pass
+
+
+class GPUScaledStub(GPUScaledTextureMixin, Stub):
+
+    internalformat = "r32f"
+
+    def _get_texture_format_for_data(self, data, internalformat=None):
+        return None
+
+
+def test_default_clim():
+    ref_data = np.array([10, 5, 15, 25, 15])
+
+    # f32
+    data = ref_data.astype(np.float32)
+    clim = get_default_clim_from_dtype(data.dtype)
+    assert clim == (0, 1)
+    clim = get_default_clim_from_data(data)
+    assert clim == (5, 25)
+
+    # i32
+    data = ref_data.astype(np.int32)
+    clim = get_default_clim_from_dtype(data.dtype)
+    assert clim == (-2**31, 2**31 - 1)
+    clim = get_default_clim_from_data(data)
+    assert clim == (5, 25)
+
+    # u8
+    data = ref_data.astype(np.uint8)
+    clim = get_default_clim_from_dtype(data.dtype)
+    assert clim == (0, 255)
+    clim = get_default_clim_from_data(data)
+    assert clim == (5, 25)
+
+
+def test_default_clim_non_finite():
+
+    data = np.array([10, np.nan, 5, 15, 25, 15]).astype(np.float32)
+    clim = get_default_clim_from_dtype(data.dtype)
+    assert clim == (0, 1)
+    clim = get_default_clim_from_data(data)
+    assert clim == (5, 25)
+
+    data = np.array([10, np.inf, 5, 15, 25, 15]).astype(np.float32)
+    clim = get_default_clim_from_dtype(data.dtype)
+    assert clim == (0, 1)
+    clim = get_default_clim_from_data(data)
+    assert clim == (5, 25)
+
+    data = np.array([10, -np.inf, 5, 15, 25, 15]).astype(np.float32)
+    clim = get_default_clim_from_dtype(data.dtype)
+    assert clim == (0, 1)
+    clim = get_default_clim_from_data(data)
+    assert clim == (5, 25)
+
+    data = np.array([np.nan, np.nan, np.nan]).astype(np.float32)
+    clim = get_default_clim_from_dtype(data.dtype)
+    assert clim == (0, 1)
+    clim = get_default_clim_from_data(data)
+    assert clim == (0, 0)
+
+    data = np.array([np.nan, np.inf, -np.inf]).astype(np.float32)
+    clim = get_default_clim_from_dtype(data.dtype)
+    assert clim == (0, 1)
+    clim = get_default_clim_from_data(data)
+    assert clim == (0, 0)
+
+
+def test_clim_handling_cpu():
+    ref_data = np.array([[10, 10, 5], [15, 25, 15]])
+
+    # f32 - auto clim
+    st = CPUScaledStub()
+    st.set_clim("auto")
+    st.scale_and_set_data(ref_data.astype(np.float32))
+    assert st.clim == (5, 25)
+    assert st.clim_normalized == (0, 1)
+    assert np.all(st._data == (ref_data - 5) / 20)
+
+    # Updating clim keeps data the same if not changing too much
+    st.set_clim((0, 20))
+    assert st.clim == (0, 20)
+    assert st.clim_normalized == (-0.25, 0.75)
+    assert np.all(st._data == (ref_data - 5) / 20)
+
+    # f32 - custom clim
+    st = CPUScaledStub()
+    st.set_clim((0, 20))
+    st.scale_and_set_data(ref_data.astype(np.float32))
+    assert st.clim == (0, 20)
+    assert st.clim_normalized == (0, 1)
+    assert np.all(st._data == ref_data / 20)
+
+    # f32 - flat clim
+    st = CPUScaledStub()
+    st.set_clim((10, 10))
+    st.scale_and_set_data(ref_data.astype(np.float32))
+    assert st.clim == (10, 10)
+    assert st.clim_normalized == (0, np.inf)
+    # assert np.min(st._data) == 0 - does not matter
+
+    # f32 - auto clim
+    st = CPUScaledStub()
+    st.set_clim("auto")
+    assert st.clim == "auto"
+    pytest.raises(RuntimeError, getattr, st, "clim_normalized")
+    st.scale_and_set_data(ref_data.astype(np.float32))
+    assert st.clim == (5, 25)
+    assert st.clim_normalized == (0, 1)
+
+    # u8 auto -> f32 auto
+    st = CPUScaledStub()
+    st.set_clim("auto")
+    assert st.clim == "auto"
+    st.scale_and_set_data(ref_data.astype(np.uint8))
+    assert st.clim == (5, 25)
+    assert st.clim_normalized == (0, 1)
+    # set new data with an out-of-range value
+    # it should clip at the limits of the original data type
+    st.set_clim("auto")
+    assert st.clim == "auto"
+    new_data = np.array([[10, 10, 5], [15, 2048, 15]], dtype=np.float32)
+    st.scale_and_set_data(new_data)
+    assert st.clim == (5, 255)
+    assert st.clim_normalized == (0, 1)
+
+
+def test_clim_handling_gpu():
+    ref_data = np.array([[10, 10, 5], [15, 25, 15]])
+
+    # f32 - auto clim
+    st = GPUScaledStub()
+    st.set_clim("auto")
+    st.scale_and_set_data(ref_data.astype(np.float32))
+    assert st.clim == (5, 25)
+    assert st.clim_normalized == (5, 25)
+    assert np.all(st._data == ref_data)
+
+    # Updating clim keeps data the same if not changing too much
+    st.set_clim((0, 20))
+    assert st.clim == (0, 20)
+    assert st.clim_normalized == (0, 20)
+    assert np.all(st._data == ref_data)
+
+    # f32 - custom clim
+    st = GPUScaledStub()
+    st.set_clim((0, 20))
+    st.scale_and_set_data(ref_data.astype(np.float32))
+    assert st.clim == (0, 20)
+    assert st.clim_normalized == (0, 20)
+    assert np.all(st._data == ref_data)
+
+    # f32 - flat clim
+    st = GPUScaledStub()
+    st.set_clim((10, 10))
+    st.scale_and_set_data(ref_data.astype(np.float32))
+    assert st.clim == (10, 10)
+    assert st.clim_normalized == (10, np.inf)
+    # assert np.min(st._data) == 0 - does not matter
+
+    # f32 - auto clim
+    st = GPUScaledStub()
+    st.set_clim("auto")
+    assert st.clim == "auto"
+    pytest.raises(RuntimeError, getattr, st, "clim_normalized")
+    st.scale_and_set_data(ref_data.astype(np.float32))
+    assert st.clim == (5.0, 25.0)
+    assert st.clim_normalized == (5.0, 25.0)
+
+
+run_tests_if_main()

vispy/visuals/tests/test_sdf.py

@@ -0,0 +1,73 @@
+# -*- coding: utf-8 -*-
+# Copyright (c) Vispy Development Team. All Rights Reserved.
+# Distributed under the (new) BSD License. See LICENSE.txt for more info.
+import gc
+
+import numpy as np
+from numpy.testing import assert_allclose
+
+from vispy.app import Canvas
+from vispy.visuals.text.text import SDFRendererCPU
+from vispy.visuals.text._sdf_gpu import SDFRendererGPU
+from vispy import gloo
+from vispy.testing import requires_application, run_tests_if_main
+
+
+@requires_application()
+def test_sdf():
+    """Test basic text support - sdf"""
+    # test a simple case
+    data = (np.array(
+        [[0, 0, 0, 0, 0, 0, 0, 0, 0],
+         [0, 0, 0, 0, 0, 0, 0, 0, 0],
+         [0, 0, 1, 1, 1, 1, 1, 0, 0],
+         [0, 0, 1, 1, 1, 1, 1, 0, 0],
+         [0, 0, 1, 1, 1, 1, 1, 0, 0],
+         [0, 0, 1, 1, 1, 1, 1, 0, 0]]) * 255).astype(np.uint8)
+
+    # The GPU data at one point were derived this way:
+    # gpu = np.array(
+    #     [[8, 5, 4, 4, 4, 4, 4, 5, 8],
+    #      [5, 2, 1, 1, 1, 1, 1, 2, 5],
+    #      [4, 1, 0, 0, 0, 0, 0, 1, 4],
+    #      [4, 1, 0, -1, -4, -1, 0, 1, 4],  # XXX artifact
+    #      [4, 1, 0, -1, -4, -1, 0, 1, 4],
+    #      [4, 1, 0, -1, -4, -1, 0, 1, 4]])
+    # gpu = 0.5 - (np.sqrt(np.abs(gpu)) * np.sign(gpu)) / 256. * 8
+    # gpu = np.round(256 * gpu).astype(np.int)
+    #
+    # But it's perhaps clearer just to give what will actually be compared:
+    gpu = np.array(
+        [[105, 110, 112, 112, 112, 112, 112, 110, 105],
+         [110, 117, 120, 120, 120, 120, 120, 117, 110],
+         [112, 120, 128, 128, 128, 128, 128, 120, 112],
+         [112, 120, 128, 136, 144, 136, 128, 120, 112],
+         [112, 120, 128, 136, 144, 136, 128, 120, 112],
+         [112, 120, 128, 136, 144, 136, 128, 120, 112]])
+    cpu = np.array(
+        [[0, 0, 0, 0, 0, 0, 0, 0, 0],
+         [0, 115, 118, 118, 118, 118, 118, 115, 0],
+         [0, 118, 137, 137, 137, 137, 137, 118, 0],
+         [0, 118, 137, 143, 143, 143, 137, 118, 0],
+         [0, 118, 137, 143, 149, 143, 137, 118, 0],
+         [0, 0, 255, 255, 255, 255, 255, 0, 0]])
+    # XXX: The GPU and CPU solutions are quite different.
+    #     It doesn't seem to have much effect on the visualizations but would be
+    #     good to fix eventually.
+
+    for Rend, expd in zip((SDFRendererGPU, SDFRendererCPU), (gpu, cpu)):
+        with Canvas(size=(100, 100)) as c:
+            tex = gloo.Texture2D(data.shape + (3,), format='rgb')
+            Rend().render_to_texture(data, tex, (0, 0), data.shape[::-1])
+            gloo.set_viewport(0, 0, *data.shape[::-1])
+            gloo.util.draw_texture(tex)
+            result = gloo.util._screenshot()[:, :, 0].astype(np.int64)
+            assert_allclose(result, expd, atol=1,
+                            err_msg=Rend.__name__)
+            del tex, result
+        del c
+        # Do some garbage collection to make sure backend applications (PyQt5) actually clear things out
+        gc.collect()
+
+
+run_tests_if_main()

vispy/visuals/tests/test_spectrogram.py

@@ -0,0 +1,42 @@
+# -*- coding: utf-8 -*-
+import numpy as np
+
+from vispy.scene.visuals import Spectrogram
+from vispy.testing import (requires_application, TestingCanvas,
+                           run_tests_if_main, raises)
+from vispy.testing.image_tester import assert_image_approved
+
+
+@requires_application()
+def test_spectrogram():
+    """Test spectrogram visual"""
+    n_fft = 256
+    n_freqs = n_fft // 2 + 1
+    size = (100, n_freqs)
+    with TestingCanvas(size=size) as c:
+        np.random.seed(67853498)
+        data = np.random.normal(size=n_fft * 100)
+        spec = Spectrogram(data, n_fft=n_fft, step=n_fft, window=None,
+                           color_scale='linear', cmap='grays')
+        c.draw_visual(spec)
+        # expected = np.zeros(size[::-1] + (3,))
+        # expected[0] = 1.
+        assert_image_approved("screenshot", "visuals/spectrogram.png")
+        freqs = spec.freqs
+        assert len(freqs) == n_freqs
+        assert freqs[0] == 0
+        assert freqs[-1] == 0.5
+
+        # Try changing all properties
+        spec.n_fft = 128
+        spec.step = 128
+        spec.fs = 2
+        spec.window = 'hann'
+        spec.normalize = True
+        spec.color_scale = 'log'
+
+        # Check color scale can be only 'log' or 'linear'
+        with raises(ValueError):
+            spec.color_scale = 'line_log'
+
+run_tests_if_main()

vispy/visuals/tests/test_surface_plot.py

@@ -0,0 +1,57 @@
+# -*- coding: utf-8 -*-
+from vispy.scene.visuals import SurfacePlot 
+from vispy.scene import TurntableCamera
+from vispy.color import get_colormap
+from vispy.testing import requires_application, TestingCanvas, run_tests_if_main
+from vispy.testing.image_tester import assert_image_reasonable
+
+import numpy as np
+import pytest
+
+
+@requires_application()
+@pytest.mark.parametrize('x1dim', [True, False])
+@pytest.mark.parametrize('y1dim', [True, False])
+@pytest.mark.parametrize('use_vertex_colors', [True, False])
+def test_surface_plot(x1dim:bool, y1dim:bool, use_vertex_colors:bool):
+    """Test SurfacePlot visual"""
+    with TestingCanvas(bgcolor='w') as c:
+        
+        # create data
+        nx, ny = (100, 150)
+        x = np.linspace(-2, 2, nx)
+        y = np.linspace(-3, 3, ny)
+        xv, yv = np.meshgrid(x, y, indexing="ij")
+        z = np.sin(xv**2 + yv**2)
+
+        view = c.central_widget.add_view()
+        view.camera = TurntableCamera(up='z', fov=60)
+
+        # color vertices
+        cnorm = z / abs(np.amax(z))
+        colormap = get_colormap("viridis").map(cnorm)
+        if not use_vertex_colors:
+            colormap = colormap.reshape(z.shape + (-1,))
+
+        # 1 or 2 dimensional x and y data
+        x_input = x if x1dim else xv
+        y_input = y if y1dim else yv
+
+        # create figure
+        surface = SurfacePlot(z=z,
+                              x=x_input,
+                              y=y_input,
+                              shading=None)
+        
+        if use_vertex_colors:
+            surface.mesh_data.set_vertex_colors(colormap)
+        else:
+            surface.set_data(colors=colormap)
+
+        # c.draw_visual(surface) 
+        view.add(surface)
+
+        assert_image_reasonable(c.render())
+
+
+run_tests_if_main()

vispy/visuals/tests/test_text.py

@@ -0,0 +1,95 @@
+# -*- coding: utf-8 -*-
+
+import numpy as np
+from numpy.testing import assert_allclose
+
+from vispy.scene.visuals import Text
+from vispy.testing import (requires_application, TestingCanvas,
+                           run_tests_if_main)
+from vispy.testing.image_tester import assert_image_approved
+
+
+@requires_application()
+def test_text():
+    """Test basic text support"""
+    with TestingCanvas(bgcolor='w', size=(92, 92), dpi=92) as c:
+        pos = [92 // 2] * 2
+        text = Text('testing', font_size=20, color='k',
+                    pos=pos, anchor_x='center', anchor_y='baseline',
+                    parent=c.scene)
+        # Test image created in Illustrator CS5, 1"x1" output @ 92 DPI
+        assert_image_approved(c.render(), 'visuals/text1.png')
+
+        text.text = ['foo', 'bar']
+        text.pos = [10, 10]  # should auto-replicate
+        text.rotation = [180, 270]
+        try:
+            text.pos = [10]
+        except Exception:
+            pass
+        else:
+            raise AssertionError('Exception not raised')
+        c.update()
+        c.app.process_events()
+        text.pos = [[10, 10], [10, 20]]
+        text.text = 'foobar'
+        c.update()
+        c.app.process_events()
+
+
+@requires_application()
+def test_text_rotation_update():
+
+    # Regression test for a bug that caused text labels to not be redrawn
+    # if the rotation angle was updated
+
+    with TestingCanvas() as c:
+        text = Text('testing', pos=(100, 100), parent=c.scene)
+        c.update()
+        c.app.process_events()
+        assert_allclose(text.shared_program['a_rotation'], 0.)
+        text.rotation = 30.
+        c.update()
+        c.app.process_events()
+        assert_allclose(text.shared_program['a_rotation'], np.radians(30.))
+
+
+@requires_application()
+def test_face_bold_italic():
+
+    with TestingCanvas() as c:
+
+        # Check defaults
+        text = Text('testing', pos=(100, 100), parent=c.scene)
+        assert not text.bold and not text.italic
+
+        # Check getter properties
+        text = Text('testing', pos=(100, 100), bold=True, italic=True, parent=c.scene)
+        assert text.bold and text.italic
+
+        # Check that changing a property changes the font object
+        font1 = text._font
+        text.bold = False
+        font2 = text._font
+        assert font1 is not font2
+        text.italic = False
+        font3 = text._font
+        assert font2 is not font3
+        text.bold = True
+        text.italic = True
+        font4 = text._font
+        assert font1 is font4
+
+
+def test_text_depth_test():
+    t = Text(depth_test=False)
+    assert not t._vshare.gl_state["depth_test"]
+
+    t = Text(depth_test=True)
+    assert t._vshare.gl_state["depth_test"]
+
+    t = Text()  # Default is false
+    assert not t._vshare.gl_state["depth_test"]
+
+
+run_tests_if_main()