vispy 0.15.0__cp312-cp312-macosx_10_13_x86_64.whl

vispy/visuals/tests/test_image_complex.py

@@ -0,0 +1,36 @@
+from vispy.scene.visuals import ComplexImage
+from vispy.visuals.image_complex import CPU_COMPLEX_TRANSFORMS
+from vispy.testing import requires_application, TestingCanvas
+from vispy.testing.image_tester import downsample
+
+import numpy as np
+import pytest
+
+from vispy.testing.rendered_array_tester import compare_render
+
+
+# we add the np.float32 case to test that ComplexImage falls back to Image behavior
+# if the data is not complex
+@requires_application()
+@pytest.mark.parametrize("input_dtype", [np.complex64, np.complex128, np.float32])
+@pytest.mark.parametrize("complex_mode", ["magnitude", "real", "imaginary", "phase"])
+def test_image_complex(input_dtype, complex_mode):
+    """Test rendering of complex-valued image data."""
+    shape = (40, 40)
+    np.random.seed(0)
+    data = np.random.random(shape).astype(input_dtype)
+    if np.iscomplexobj(data):
+        data.imag = np.random.random(shape)
+
+    with TestingCanvas(size=shape, bgcolor="w") as c:
+        ComplexImage(data, cmap="grays", complex_mode=complex_mode, parent=c.scene)
+        # render to canvas
+        rendered = c.render()
+        shape_ratio = rendered.shape[0] // data.shape[0]
+        rendered = downsample(rendered, shape_ratio, axis=(0, 1))
+
+        # perform (auto-clim) rendering on cpu
+        exp = CPU_COMPLEX_TRANSFORMS[complex_mode](data) if np.iscomplexobj(data) else data
+        exp -= exp.min()
+        exp /= exp.max()
+        compare_render(exp, rendered)

vispy/visuals/tests/test_infinite_line.py

@@ -0,0 +1,53 @@
+# -*- coding: utf-8 -*-
+# Copyright (c) Vispy Development Team. All Rights Reserved.
+# Distributed under the (new) BSD License. See LICENSE.txt for more info.
+
+"""
+Tests for InfiniteLineVisual
+All images are of size (100,100) to keep a small file size
+"""
+
+import numpy as np
+
+from vispy.scene import visuals
+from vispy.testing import (requires_application, TestingCanvas,
+                           run_tests_if_main)
+from vispy.testing.image_tester import assert_image_approved
+from vispy.testing import assert_raises
+
+
+@requires_application()
+def test_set_data():
+    """Test InfiniteLineVisual"""
+    pos = 5.0
+    color = [1.0, 1.0, 0.5, 0.5]
+    expected_color = np.array(color, dtype=np.float32)
+
+    for is_vertical, reference_image in [(True, 'infinite_line.png'),
+                                         (False, 'infinite_line_h.png')]:
+
+        with TestingCanvas() as c:
+            # Check set_data is working correctly within visual constructor
+            region = visuals.InfiniteLine(pos=pos,
+                                          color=color,
+                                          vertical=is_vertical,
+                                          parent=c.scene)
+            assert region.pos == pos
+            assert np.all(region.color == expected_color)
+            assert region.is_vertical == is_vertical
+
+            # Check tuple color argument is accepted
+            region.set_data(color=tuple(color))
+            assert np.all(region.color == expected_color)
+
+            assert_image_approved(c.render(), 'visuals/%s' % reference_image)
+
+            # Check only numbers are accepted
+            assert_raises(TypeError, region.set_data, pos=[[1, 2], [3, 4]])
+
+            # Check color argument can be only a 4 length 1D array
+            assert_raises(ValueError, region.set_data, color=[[1, 2], [3, 4]])
+            assert_raises(ValueError, region.set_data, color=[1, 2])
+
+
+run_tests_if_main()

vispy/visuals/tests/test_instanced_mesh.py

@@ -0,0 +1,50 @@
+import numpy as np
+from vispy import scene, use
+
+from vispy.testing import (TestingCanvas, requires_application,
+                           run_tests_if_main, requires_pyopengl)
+
+
+def setup_module(module):
+    use(gl='gl+')
+
+
+def teardown_module(module):
+    use(gl='gl2')
+
+
+@requires_pyopengl()
+@requires_application()
+def test_mesh_with_vertex_values():
+    size = (80, 60)
+    with TestingCanvas(size=size) as c:
+        use(gl='gl+')
+        vert = np.array([[0, 0, 0], [0, 30, 0], [40, 0, 0]])
+        faces = np.array([0, 1, 2])
+        pos = np.array([[0, 0, 0], [80, 60, 0]])
+        # identity and rotate 180
+        trans = np.array([
+            [
+                [1, 0, 0],
+                [0, 1, 0],
+                [0, 0, 1],
+            ],
+            [
+                [-1, 0, 0],
+                [0, -1, 0],
+                [0, 0, 1],
+            ],
+        ])
+        colors = ['red', 'blue']
+        mesh = scene.visuals.InstancedMesh(
+            vertices=vert, faces=faces, instance_positions=pos, instance_transforms=trans, instance_colors=colors
+        )
+        v = c.central_widget.add_view(border_width=0)
+        v.add(mesh)
+        render = c.render()
+        assert np.allclose(render[10, 10], (255, 0, 0, 255))
+        assert np.allclose(render[-10, -10], (0, 0, 255, 255))
+        assert np.allclose(render[30, 40], (0, 0, 0, 255))
+
+
+run_tests_if_main()

vispy/visuals/tests/test_isosurface.py

@@ -0,0 +1,22 @@
+# -*- coding: utf-8 -*-
+
+import numpy as np
+from vispy import scene
+
+from vispy.testing import run_tests_if_main, requires_pyopengl
+
+
+@requires_pyopengl()
+def test_isosurface():
+
+    # Create data
+    vol = np.arange(1000).reshape((10, 10, 10)).astype(np.float32)
+
+    # Create visual
+    iso = scene.visuals.Isosurface(vol, level=200)
+
+    # Change color (regression test for a bug that caused this to crash)
+    iso.color = (1.0, 0.8, 0.9, 1.0)
+
+
+run_tests_if_main()

vispy/visuals/tests/test_linear_region.py

@@ -0,0 +1,152 @@
+# -*- coding: utf-8 -*-
+# Copyright (c) Vispy Development Team. All Rights Reserved.
+# Distributed under the (new) BSD License. See LICENSE.txt for more info.
+
+"""
+Tests for LinearRegionVisual
+All images are of size (100,100) to keep a small file size
+"""
+
+import numpy as np
+
+from vispy.scene import visuals
+from vispy.testing import (requires_application, TestingCanvas,
+                           run_tests_if_main)
+from vispy.testing.image_tester import assert_image_approved
+from vispy.testing import assert_raises
+
+
+@requires_application()
+def test_linear_region_vertical_horizontal():
+    """Test vertical and horizontal LinearRegionVisual with a single color"""
+    # Definition of the region
+    pos = np.array([5, 15, 24, 36, 40, 42], dtype=np.float32)
+    # Expected internal pos buffer for vertical region
+    expected_pos_v = np.array([[5.0, -1.],
+                               [5.0, 1.],
+                               [15.0, -1.],
+                               [15.0, 1.],
+                               [24.0, -1.],
+                               [24.0, 1.],
+                               [36.0, -1.],
+                               [36.0, 1.],
+                               [40.0, -1.],
+                               [40.0, 1.],
+                               [42.0, -1.],
+                               [42.0, 1.]], dtype=np.float32)
+    # Expected internal pos buffer for horizontal region
+    expected_pos_h = np.array([expected_pos_v[:, 1] * -1,
+                               expected_pos_v[:, 0]], dtype=np.float32).T
+
+    # Test both horizontal and vertical region
+    for is_vertical, reference_image in [(True, 'linear_region1.png'),
+                                         (False, 'linear_region1_h.png')]:
+
+        expected_pos = expected_pos_v if is_vertical else expected_pos_h
+
+        with TestingCanvas() as c:
+            # Check set_data is working correctly within visual constructor
+            region = visuals.LinearRegion(pos=pos,
+                                          color=[0.0, 1.0, 0.0, 0.5],
+                                          vertical=is_vertical,
+                                          parent=c.scene)
+            assert np.all(region._pos == expected_pos)
+            assert np.all(region.pos == pos)
+            assert region.is_vertical == is_vertical
+
+            # Check set_data is working as expected when passing a list as
+            # pos argument
+            region.set_data(pos=list(pos))
+            assert np.all(region._pos == expected_pos)
+            assert np.all(region.pos == pos)
+
+            # Check set_data is working as expected when passing a tuple as
+            # pos argument
+            region.set_data(pos=tuple(pos))
+            assert np.all(region._pos == expected_pos)
+            assert np.all(region.pos == pos)
+
+            # Test with different dtypes that must be converted to float32
+            for t in [np.int64, np.float64, np.int32]:
+                region.set_data(pos=pos.astype(t))
+                assert np.all(region._pos == expected_pos)
+                assert np.all(region.pos == pos)
+
+            assert_image_approved(c.render(), 'visuals/%s' % reference_image)
+
+            # Check ValueError is raised when pos is not 1D
+            assert_raises(ValueError, region.set_data, pos=[[1, 2], [3, 4]])
+
+
+@requires_application()
+def test_linear_region_color():
+    """Test the color argument of LinearRegionVisual.set_data() method
+    using a single color
+    """
+    # Definition of the region
+    pos1 = [5, 42]
+    # Definition of the color of the region
+    color1 = np.array([0.0, 1.0, 0.0, 0.5], dtype=np.float32)
+    # Expected internal color buffer
+    color1_expected = np.array([color1, color1, color1, color1],
+                               dtype=np.float32)
+
+    with TestingCanvas() as c:
+        # Check set_data is working correctly within visual constructor
+        region = visuals.LinearRegion(pos=pos1, color=color1, parent=c.scene)
+        assert np.all(region._color == color1_expected)
+        assert np.all(region.color == color1)
+
+        # Check set_data is working as expected when passing a list as
+        # color argument
+        region.set_data(color=list(color1))
+        assert np.all(region._color == color1_expected)
+        assert np.all(region.color == color1)
+
+        # Check set_data is working as expected when passing a tuple as
+        # color argument
+        region.set_data(color=tuple(color1))
+        assert np.all(region._color == color1_expected)
+        assert np.all(region.color == color1)
+
+        # Test with different dtypes that must be converted to float32
+        region.set_data(color=color1.astype(np.float64))
+        assert np.all(region._color == color1_expected)
+        assert np.all(region.color == color1)
+
+        assert_image_approved(c.render(), 'visuals/linear_region1.png')
+
+        # Check a ValueError is raised when the length of color argument
+        # is not 4.
+        assert_raises(ValueError, region.set_data, color=[1.0, 0.5, 0.5])
+
+        # Check a ValueError is raised when too many colors are provided
+        assert_raises(ValueError, region.set_data,
+                      color=[color1, color1, color1])
+
+
+@requires_application()
+def test_linear_region_gradient():
+    """Test LinearRegionVisual with a gradient as color"""
+    # Definition of the region
+    pos2 = [5, 42, 80]
+    # Definition of the color of the region
+    color2 = np.array([[0.0, 1.0, 0.0, 0.5],
+                       [1.0, 0.0, 0.0, 0.75],
+                       [0.0, 0.0, 1.0, 1.0]], dtype=np.float32)
+    # Expected internal color buffer
+    color2_expected = np.array([color2[0], color2[0],
+                                color2[1], color2[1],
+                                color2[2], color2[2]],
+                               dtype=np.float32)
+
+    with TestingCanvas() as c:
+        # Check set_data is working correctly within visual constructor
+        region = visuals.LinearRegion(pos=pos2, color=color2, parent=c.scene)
+        assert np.all(region._color == color2_expected)
+        assert np.all(region.color == color2)
+
+        assert_image_approved(c.render(), 'visuals/linear_region2.png')
+
+
+run_tests_if_main()

vispy/visuals/tests/test_markers.py

@@ -0,0 +1,54 @@
+# -*- coding: utf-8 -*-
+import numpy as np
+import pytest
+from vispy.scene.visuals import Markers
+from vispy.testing import (requires_application, TestingCanvas,
+                           run_tests_if_main)
+from vispy.testing.image_tester import assert_image_approved
+
+
+@requires_application()
+def test_markers():
+    """Test basic marker / point-sprite support"""
+    # this is probably too basic, but it at least ensures that point sprites
+    # work for people
+    np.random.seed(57983)
+    data = np.random.normal(size=(30, 2), loc=50, scale=10)
+
+    with TestingCanvas() as c:
+        marker = Markers(parent=c.scene)
+        marker.set_data(data)
+        assert_image_approved(c.render(), "visuals/markers.png")
+
+    # Test good correlation at high-dpi
+    with TestingCanvas(px_scale=2) as c:
+        marker = Markers(parent=c.scene)
+        marker.set_data(data)
+        assert_image_approved(c.render(), "visuals/markers.png")
+
+
+def test_markers_edge_width():
+    data = np.random.rand(10, 3)
+    edge_width = np.random.rand(10)
+    marker = Markers()
+
+    with pytest.raises(ValueError):
+        marker.set_data(pos=data, edge_width_rel=1, edge_width=1)
+
+    marker.set_data(pos=data, edge_width=2)
+    marker.set_data(pos=data, edge_width=edge_width)
+    with pytest.raises(ValueError):
+        marker.set_data(pos=data, edge_width=-1)
+
+    marker.set_data(pos=data, edge_width_rel=edge_width, edge_width=None)
+    marker.set_data(pos=data, edge_width_rel=edge_width + 1, edge_width=None)
+    with pytest.raises(ValueError):
+        marker.set_data(pos=data, edge_width_rel=edge_width - 1, edge_width=None)
+
+
+def test_empty_markers_symbol():
+    markers = Markers()
+    markers.symbol = 'o'
+
+
+run_tests_if_main()

vispy/visuals/tests/test_mesh.py

@@ -0,0 +1,261 @@
+# -*- coding: utf-8 -*-
+
+import numpy as np
+from vispy import scene
+
+from vispy.color import Color
+from vispy.geometry import create_cube, create_sphere
+from vispy.testing import (TestingCanvas, requires_application,
+                           run_tests_if_main, requires_pyopengl)
+from vispy.visuals.filters import ShadingFilter, WireframeFilter
+from vispy.visuals.filters.mesh import _as_rgba
+
+import pytest
+
+
+@requires_pyopengl()
+def test_mesh_color():
+    # Create visual
+    vertices, filled_indices, outline_indices = create_cube()
+    axis = scene.visuals.Mesh(vertices['position'], outline_indices,
+                              color='black', mode='lines')
+
+    # Change color (regression test for a bug that caused this to reset
+    # the vertex data to None)
+
+    axis.color = (0.1, 0.3, 0.7, 0.9)
+
+    new_vertices = axis.mesh_data.get_vertices()
+
+    np.testing.assert_allclose(axis.color.rgba, (0.1, 0.3, 0.7, 0.9))
+    np.testing.assert_allclose(vertices['position'], new_vertices)
+
+
+@requires_pyopengl()
+@requires_application()
+def test_mesh_with_vertex_values():
+    size = (45, 40)
+    with TestingCanvas(size=size) as c:
+        v = c.central_widget.add_view(border_width=0)
+        vertices = np.array([(0, 0, 0), (0, 0, 1), (1, 0, 0)], dtype=float)
+        faces = np.array([(0, 1, 2)])
+        mesh = scene.visuals.Mesh(
+            vertices=vertices,
+            faces=faces,
+            vertex_values=np.ones(len(vertices)),
+        )
+        v.add(mesh)
+        c.render()
+
+
+@requires_pyopengl()
+@requires_application()
+@pytest.mark.parametrize('shading', [None, 'flat', 'smooth'])
+def test_mesh_shading_change_from_none(shading):
+    # Regression test for #2041: exception raised when changing the shading
+    # mode with shading=None initially.
+    size = (45, 40)
+    with TestingCanvas(size=size) as c:
+        v = c.central_widget.add_view(border_width=0)
+        vertices = np.array([(0, 0, 0), (0, 0, 1), (1, 0, 0)], dtype=float)
+        faces = np.array([(0, 1, 2)])
+        mesh = scene.visuals.Mesh(vertices=vertices, faces=faces, shading=None)
+        v.add(mesh)
+        c.render()
+        # This below should not fail.
+        mesh.shading = shading
+        c.render()
+
+
+@requires_pyopengl()
+@requires_application()
+@pytest.mark.parametrize('shading', [None, 'flat', 'smooth'])
+def test_mesh_shading_filter(shading):
+    size = (45, 40)
+    with TestingCanvas(size=size, bgcolor="k") as c:
+        v = c.central_widget.add_view(border_width=0)
+        v.camera = 'arcball'
+        mdata = create_sphere(20, 30, radius=1)
+        mesh = scene.visuals.Mesh(meshdata=mdata,
+                                  shading=shading,
+                                  color=(0.2, 0.3, 0.7, 1.0))
+        v.add(mesh)
+
+        rendered = c.render()[..., 0]  # R channel only
+        if shading in ("flat", "smooth"):
+            # there should be a gradient, not solid colors
+            assert np.unique(rendered).size >= 28
+            # sphere/circle is "dark" on the right and gets brighter as you
+            # move to the left, then hits a bright spot and decreases after
+            invest_row = rendered[34].astype(np.float64)
+            # overall, we should be increasing brightness up to a "bright spot"
+            assert (np.diff(invest_row[34:60]) <= 0).all()
+        else:
+            assert np.unique(rendered).size == 2
+
+
+def test_intensity_or_color_as_rgba():
+    assert _as_rgba(0.3) == Color((1.0, 1.0, 1.0, 0.3))
+    assert _as_rgba((0.3, 0.2, 0.1)) == Color((0.3, 0.2, 0.1, 1.0))
+    assert _as_rgba((0.3, 0.2, 0.1, 0.5)) == Color((0.3, 0.2, 0.1, 0.5))
+
+
+@requires_pyopengl()
+@requires_application()
+@pytest.mark.parametrize('shading', [None, 'flat', 'smooth'])
+def test_mesh_shading_filter_enabled(shading):
+    size = (45, 40)
+    with TestingCanvas(size=size, bgcolor="k") as c:
+        v = c.central_widget.add_view(border_width=0)
+        v.camera = 'arcball'
+        mdata = create_sphere(20, 30, radius=1)
+        mesh = scene.visuals.Mesh(meshdata=mdata,
+                                  shading=None,
+                                  color=(0.2, 0.3, 0.7, 1.0))
+        shading_filter = ShadingFilter(shading=shading)
+        mesh.attach(shading_filter)
+        v.add(mesh)
+
+        shading_filter.enabled = False
+        rendered_without_shading = c.render()
+
+        shading_filter.enabled = True
+        rendered_with_shading = c.render()
+
+        if shading is None:
+            # There should be no shading applied, regardless of the value of
+            # `enabled`.
+            assert np.allclose(rendered_without_shading, rendered_with_shading)
+        else:
+            # The result should be different with shading applied.
+            assert not np.allclose(rendered_without_shading,
+                                   rendered_with_shading)
+
+
+@requires_pyopengl()
+@requires_application()
+@pytest.mark.parametrize('attribute', ['ambient_coefficient',
+                                       'diffuse_coefficient',
+                                       'specular_coefficient',
+                                       'ambient_light',
+                                       'diffuse_light',
+                                       'specular_light'])
+def test_mesh_shading_filter_colors(attribute):
+    size = (45, 40)
+    with TestingCanvas(size=size, bgcolor="k") as c:
+        base_color_white = (1.0, 1.0, 1.0, 1.0)
+        overlay_color_red = (1.0, 0.0, 0.0, 1.0)
+
+        v = c.central_widget.add_view(border_width=0)
+        v.camera = 'arcball'
+        mdata = create_sphere(20, 30, radius=1)
+        mesh = scene.visuals.Mesh(meshdata=mdata, color=base_color_white)
+        v.add(mesh)
+
+        shading_filter = ShadingFilter(shading='smooth',
+                                       # Set the light source on the side of
+                                       # and around the camera to get a clearly
+                                       # visible reflection.
+                                       light_dir=(-5, -5, 5),
+                                       # Activate all illumination types as
+                                       # white light but reduce the intensity
+                                       # to prevent saturation.
+                                       ambient_light=0.3,
+                                       diffuse_light=0.3,
+                                       specular_light=0.3,
+                                       # Get a wide highlight.
+                                       shininess=4)
+        mesh.attach(shading_filter)
+
+        rendered_white = c.render()
+
+        setattr(shading_filter, attribute, overlay_color_red)
+        rendered_red = c.render()
+
+        # The results should be different.
+        assert not np.allclose(rendered_white, rendered_red)
+
+        # There should be an equal amount of all colors in the white rendering.
+        color_count_white = rendered_white.sum(axis=(0, 1))
+        r, g, b, _ = color_count_white
+        assert r == g and r == b
+
+        color_count_red = rendered_red.sum(axis=(0, 1))
+        # There should be more red in the red-colored rendering.
+        r, g, b, _ = color_count_red
+        assert r > g and r > b
+
+
+@requires_pyopengl()
+def test_mesh_bounds():
+    # Create 3D visual
+    vertices, filled_indices, outline_indices = create_cube()
+    axis = scene.visuals.Mesh(vertices['position'], outline_indices,
+                              color='black', mode='lines')
+
+    # Test bounds for all 3 axes
+    for i in range(3):
+        np.testing.assert_allclose(axis.bounds(i), (-1.0, 1.0))
+
+    # Create 2D visual using projection of cube
+    axis = scene.visuals.Mesh(vertices['position'][:, :2], outline_indices,
+                              color='black', mode='lines')
+
+    # Test bounds for first 2 axes
+    for i in range(2):
+        np.testing.assert_allclose(axis.bounds(i), (-1.0, 1.0))
+    # Test bounds for 3rd axis
+    np.testing.assert_allclose(axis.bounds(2), (0.0, 0.0))
+
+
+@requires_pyopengl()
+@requires_application()
+def test_mesh_wireframe_filter():
+    size = (45, 40)
+    with TestingCanvas(size=size, bgcolor="k") as c:
+        v = c.central_widget.add_view(border_width=0)
+        # Create visual
+        mdata = create_sphere(20, 40, radius=20)
+        mesh = scene.visuals.Mesh(meshdata=mdata,
+                                  shading=None,
+                                  color=(0.1, 0.3, 0.7, 0.9))
+        wireframe_filter = WireframeFilter(color='red')
+        mesh.attach(wireframe_filter)
+        v.add(mesh)
+        from vispy.visuals.transforms import STTransform
+        mesh.transform = STTransform(translate=(20, 20))
+        mesh.transforms.scene_transform = STTransform(scale=(1, 1, 0.01))
+
+        rendered_with_wf = c.render()
+        assert np.unique(rendered_with_wf[..., 0]).size >= 50
+
+        wireframe_filter.enabled = False
+        rendered_wo_wf = c.render()
+        # the result should be completely different
+        # assert not allclose
+        pytest.raises(AssertionError, np.testing.assert_allclose,
+                      rendered_with_wf, rendered_wo_wf)
+
+        wireframe_filter.enabled = True
+        wireframe_filter.wireframe_only = True
+        rendered_with_wf_only = c.render()
+        # the result should be different from the two cases above
+        pytest.raises(AssertionError, np.testing.assert_allclose,
+                      rendered_with_wf_only, rendered_with_wf)
+        pytest.raises(AssertionError, np.testing.assert_allclose,
+                      rendered_with_wf_only, rendered_wo_wf)
+
+        wireframe_filter.enabled = True
+        wireframe_filter.wireframe_only = False
+        wireframe_filter.faces_only = True
+        rendered_with_faces_only = c.render()
+        # the result should be different from the cases above
+        pytest.raises(AssertionError, np.testing.assert_allclose,
+                      rendered_with_faces_only, rendered_with_wf)
+        pytest.raises(AssertionError, np.testing.assert_allclose,
+                      rendered_with_faces_only, rendered_wo_wf)
+        pytest.raises(AssertionError, np.testing.assert_allclose,
+                      rendered_with_faces_only, rendered_with_wf_only)
+
+
+run_tests_if_main()