vispy 0.15.0__cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl

vispy/visuals/tests/test_mesh_normals.py

@@ -0,0 +1,218 @@
+# -*- coding: utf-8 -*-
+
+import numpy as np
+import pytest
+
+from vispy import scene
+from vispy.geometry import create_sphere
+from vispy.testing import (TestingCanvas, requires_application,
+                           run_tests_if_main, requires_pyopengl)
+
+
+@requires_pyopengl()
+@requires_application()
+def test_mesh_normals():
+    size = (45, 40)
+    with TestingCanvas(size=size, bgcolor="k") as c:
+        v = c.central_widget.add_view(border_width=0)
+        v.camera = 'arcball'
+        # Create visual.
+        mdata = create_sphere(radius=1.0)
+        mesh = scene.visuals.Mesh(meshdata=mdata,
+                                  shading=None,
+                                  color=(0.1, 0.1, 0.1, 1.0))
+        v.add(mesh)
+
+        rendered_without_normals = c.render()
+        # The color should be of low intensity.
+        assert np.all((rendered_without_normals[..., 0:3]) < 32)
+
+        face_normals = scene.visuals.MeshNormals(mdata, primitive="face",
+                                                 color=(1, 0, 0))
+        face_normals.parent = mesh
+        rendered_with_face_normals = c.render()
+        face_normals.parent = None
+        # There should be some pixels with brighter red.
+        assert np.sum(rendered_with_face_normals[..., 0] > 128) > 64
+        pytest.raises(AssertionError, np.testing.assert_allclose,
+                      rendered_without_normals, rendered_with_face_normals)
+
+        vertex_normals = scene.visuals.MeshNormals(mdata, primitive="vertex",
+                                                   color=(0, 1, 0))
+        vertex_normals.parent = mesh
+        rendered_with_vertex_normals = c.render()
+        vertex_normals.parent = None
+        # There should be some pixels with brighter green.
+        assert np.sum(rendered_with_vertex_normals[..., 1] > 128) > 64
+        pytest.raises(AssertionError, np.testing.assert_allclose,
+                      rendered_without_normals, rendered_with_vertex_normals)
+        pytest.raises(AssertionError, np.testing.assert_allclose,
+                      rendered_with_face_normals, rendered_with_vertex_normals)
+
+
+@requires_pyopengl()
+@requires_application()
+def test_mesh_normals_length_scalar():
+    size = (45, 40)
+    with TestingCanvas(size=size, bgcolor="k") as c:
+        v = c.central_widget.add_view(border_width=0)
+        v.camera = 'arcball'
+        # Create visual.
+        mdata = create_sphere(radius=1.0)
+        mesh = scene.visuals.Mesh(meshdata=mdata,
+                                  shading=None,
+                                  color=(0.1, 0.1, 0.1, 1.0))
+        v.add(mesh)
+
+        length = 0.5
+        normals_0_5 = scene.visuals.MeshNormals(mdata, color=(1, 0, 0),
+                                                length=length)
+        normals_0_5.parent = mesh
+        rendered_length_0_5 = c.render()
+        normals_0_5.parent = None
+
+        length = 1.0
+        normals_1_0 = scene.visuals.MeshNormals(mdata, color=(1, 0, 0),
+                                                length=length)
+        normals_1_0.parent = mesh
+        rendered_length_1_0 = c.render()
+        normals_1_0.parent = None
+
+        # There should be more red pixels with the longer normals.
+        n_pixels_0_5 = np.sum(rendered_length_0_5[..., 0] > 128)
+        n_pixels_1_0 = np.sum(rendered_length_1_0[..., 0] > 128)
+        assert n_pixels_1_0 > n_pixels_0_5
+
+
+@requires_pyopengl()
+@requires_application()
+@pytest.mark.parametrize('primitive', ['face', 'vertex'])
+def test_mesh_normals_length_array(primitive):
+    size = (45, 40)
+    with TestingCanvas(size=size, bgcolor="k") as c:
+        v = c.central_widget.add_view(border_width=0)
+        v.camera = 'arcball'
+        v.camera.fov = 90
+        # Create visual.
+        meshdata = create_sphere(radius=1.0)
+        mesh = scene.visuals.Mesh(meshdata=meshdata,
+                                  shading=None,
+                                  color=(0.1, 0.1, 0.1, 1.0))
+        v.add(mesh)
+
+        if primitive == 'face':
+            n_normals = len(meshdata.get_faces())
+        elif primitive == 'vertex':
+            n_normals = len(meshdata.get_vertices())
+
+        lengths_0_5 = np.full(n_normals, 0.5, dtype=float)
+        normals_0_5 = scene.visuals.MeshNormals(meshdata, primitive=primitive,
+                                                color=(1, 0, 0),
+                                                length=lengths_0_5)
+        normals_0_5.parent = mesh
+        rendered_lengths_0_5 = c.render()
+        normals_0_5.parent = None
+
+        lengths_1_0 = np.full(n_normals, 1.0, dtype=float)
+        normals_1_0 = scene.visuals.MeshNormals(meshdata, primitive=primitive,
+                                                color=(1, 0, 0),
+                                                length=lengths_1_0)
+        normals_1_0.parent = mesh
+        rendered_lengths_1_0 = c.render()
+        normals_1_0.parent = None
+
+        # There should be more red pixels with the longer normals.
+        n_pixels_0_5 = np.sum(rendered_lengths_0_5[..., 0] > 128)
+        n_pixels_1_0 = np.sum(rendered_lengths_1_0[..., 0] > 128)
+        assert n_pixels_1_0 > n_pixels_0_5
+
+        lengths_ramp = np.linspace(0.5, 1.0, n_normals, dtype=float)
+        normals_ramp = scene.visuals.MeshNormals(meshdata, primitive=primitive,
+                                                 color=(1, 0, 0),
+                                                 length=lengths_ramp)
+        normals_ramp.parent = mesh
+        rendered_lengths_ramp = c.render()
+        normals_ramp.parent = None
+
+        # With the normals lengths from a ramp in [0.5, 1.0], there should be
+        # more red pixels than with all normals of length 0.5 and less than
+        # with all normals of length 1.0.
+        n_pixels_ramp = np.sum(rendered_lengths_ramp[..., 0] > 128)
+        assert n_pixels_0_5 < n_pixels_ramp < n_pixels_1_0
+
+
+@requires_pyopengl()
+@requires_application()
+def test_mesh_normals_length_scale():
+    size = (45, 40)
+    with TestingCanvas(size=size, bgcolor="k") as c:
+        v = c.central_widget.add_view(border_width=0)
+        v.camera = 'arcball'
+        # Create visual.
+        meshdata = create_sphere(radius=1.0)
+        mesh = scene.visuals.Mesh(meshdata=meshdata,
+                                  shading=None,
+                                  color=(0.1, 0.1, 0.1, 1.0))
+        v.add(mesh)
+
+        length = 1.0
+        length_scale_up = 2.0
+        length_scale_down = 0.5
+
+        normals = scene.visuals.MeshNormals(meshdata, color=(1, 0, 0),
+                                            length=length)
+        normals.parent = mesh
+        rendered_length_default = c.render()
+        normals.parent = None
+
+        normals_scaled_up = scene.visuals.MeshNormals(
+            meshdata, color=(1, 0, 0), length=length,
+            length_scale=length_scale_up)
+        normals_scaled_up.parent = mesh
+        rendered_length_scaled_up = c.render()
+        normals_scaled_up.parent = None
+
+        normals_scaled_down = scene.visuals.MeshNormals(
+            meshdata, color=(1, 0, 0), length=length,
+            length_scale=length_scale_down)
+        normals_scaled_down.parent = mesh
+        rendered_length_scaled_down = c.render()
+        normals_scaled_down.parent = None
+
+        # There should be more red pixels with the scaled-up normals and less
+        # with the ones scaled down.
+        n_pixels_default = np.sum(rendered_length_default[..., 0] > 128)
+        n_pixels_scaled_up = np.sum(rendered_length_scaled_up[..., 0] > 128)
+        n_pixels_scaled_down = np.sum(rendered_length_scaled_down[..., 0] > 128)
+        assert n_pixels_scaled_down < n_pixels_default < n_pixels_scaled_up
+
+
+@requires_pyopengl()
+@requires_application()
+@pytest.mark.parametrize('length_method', ['median_edge', 'max_extent'])
+def test_mesh_normals_length_method(length_method):
+    size = (45, 40)
+    with TestingCanvas(size=size, bgcolor="k") as c:
+        v = c.central_widget.add_view(border_width=0)
+        v.camera = 'arcball'
+        # Create visual.
+        meshdata = create_sphere(radius=1.0)
+        mesh = scene.visuals.Mesh(meshdata=meshdata,
+                                  shading=None,
+                                  color=(0.1, 0.1, 0.1, 1.0))
+        v.add(mesh)
+
+        # The code below should not raise.
+        # XXX(asnt): Not sure how to better test `length_method`.
+        normals = scene.visuals.MeshNormals(meshdata, color=(1, 0, 0),
+                                            length_method=length_method)
+        normals.parent = mesh
+        _ = c.render()
+
+
+def test_mesh_normals_empty():
+    mesh = scene.visuals.Mesh()
+    scene.visuals.MeshNormals(mesh.mesh_data)
+
+
+run_tests_if_main()

vispy/visuals/tests/test_polygon.py

@@ -0,0 +1,112 @@
+# -*- coding: utf-8 -*-
+
+"""
+Tests for PolygonVisual
+All images are of size (100,100) to keep a small file size
+"""
+
+import numpy as np
+
+from vispy.scene import visuals, transforms
+from vispy.testing import (requires_application, requires_scipy, TestingCanvas,
+                           run_tests_if_main)
+from vispy.testing.image_tester import assert_image_approved
+
+
+@requires_application()
+@requires_scipy()
+def test_square_draw():
+    """Test drawing squares without transforms using PolygonVisual"""
+    pos = np.array([[-0.5, 0.5, 0],
+                    [0.5, 0.5, 0],
+                    [0.5, -0.5, 0],
+                    [-0.5, -0.5, 0]])
+    with TestingCanvas() as c:
+        polygon = visuals.Polygon(pos=pos, color=(1, 0, 0, 1),
+                                  parent=c.scene)
+        polygon.transform = transforms.STTransform(scale=(50, 50),
+                                                   translate=(50, 50))
+
+        assert_image_approved(c.render(), 'visuals/square1.png')
+
+        polygon.parent = None
+        polygon = visuals.Polygon(pos=pos, color=(1, 0, 0, 1),
+                                  border_color=(1, 1, 1, 1),
+                                  parent=c.scene)
+        polygon.transform = transforms.STTransform(scale=(50, 50),
+                                                   translate=(50, 50))
+
+        assert_image_approved(c.render(), 'visuals/square2.png')
+
+        polygon.parent = None
+        polygon = visuals.Polygon(pos=pos, border_color=(1, 1, 1, 1),
+                                  parent=c.scene)
+        polygon.transform = transforms.STTransform(scale=(50, 50),
+                                                   translate=(50, 50))
+
+        assert_image_approved(c.render(), 'visuals/square3.png',
+                              min_corr=0.45)
+
+
+@requires_application()
+@requires_scipy()
+def test_rectangle_draw():
+    """Test drawing rectangles with transforms using PolygonVisual"""
+    pos = np.array([[-0.1, 0.5, 0],
+                    [0.1, 0.5, 0],
+                    [0.1, -0.5, 0],
+                    [-0.1, -0.5, 0]])
+    with TestingCanvas() as c:
+        polygon = visuals.Polygon(pos=pos, color=(1, 1, 0, 1), parent=c.scene)
+        polygon.transform = transforms.STTransform(scale=(200.0, 25),
+                                                   translate=(50, 50))
+
+        assert_image_approved(c.render(), 'visuals/rectangle1.png')
+
+        polygon.parent = None
+        polygon = visuals.Polygon(pos=pos, color=(1, 1, 0, 1),
+                                  border_color=(1, 0, 0, 1),
+                                  parent=c.scene)
+        polygon.transform = transforms.STTransform(scale=(200.0, 25),
+                                                   translate=(50, 50))
+
+        assert_image_approved(c.render(), 'visuals/rectangle2.png')
+
+        polygon.parent = None
+        polygon = visuals.Polygon(pos=pos, border_color=(1, 0, 0, 1),
+                                  border_width=1, parent=c.scene)
+        polygon.transform = transforms.STTransform(scale=(200.0, 25),
+                                                   translate=(50, 49))
+
+        assert_image_approved(c.render(), 'visuals/rectangle3.png',
+                              min_corr=0.7)
+
+
+@requires_application()
+@requires_scipy()
+def test_reactive_draw():
+    """Test reactive polygon attributes"""
+    pos = np.array([[-0.1, 0.5, 0],
+                    [0.1, 0.5, 0],
+                    [0.1, -0.5, 0],
+                    [-0.1, -0.5, 0]])
+    with TestingCanvas() as c:
+        polygon = visuals.Polygon(pos=pos, color='yellow', parent=c.scene)
+        polygon.transform = transforms.STTransform(scale=(50, 50),
+                                                   translate=(50, 50))
+
+        polygon.pos += [0.1, -0.1, 0]
+
+        assert_image_approved(c.render(), 'visuals/reactive_polygon1.png')
+
+        polygon.color = 'red'
+
+        assert_image_approved(c.render(), 'visuals/reactive_polygon2.png')
+
+        polygon.border_color = 'yellow'
+
+        assert_image_approved(c.render(), 'visuals/reactive_polygon3.png',
+                              min_corr=0.8)
+
+
+run_tests_if_main()

vispy/visuals/tests/test_rectangle.py

@@ -0,0 +1,163 @@
+# -*- coding: utf-8 -*-
+
+"""
+Tests for RectPolygonVisual
+All images are of size (100,100) to keep a small file size
+"""
+
+from vispy.scene import visuals, transforms
+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_rectangle_draw():
+    """Test drawing rectpolygons without transform using RectPolygonVisual"""
+    with TestingCanvas() as c:
+        rectpolygon = visuals.Rectangle(center=(50, 50, 0), height=40.,
+                                        width=80., color='red',
+                                        parent=c.scene)
+
+        assert_image_approved(c.render(), 'visuals/rectpolygon1.png')
+
+        rectpolygon.parent = None
+        rectpolygon = visuals.Rectangle(center=(50, 50, 0), height=40.,
+                                        width=80., radius=10., color='red',
+                                        parent=c.scene)
+
+        assert_image_approved(c.render(), 'visuals/rectpolygon2.png')
+
+        rectpolygon.parent = None
+        rectpolygon = visuals.Rectangle(center=(50, 50, 0), height=40.,
+                                        width=80., radius=10., color='red',
+                                        border_color=(0, 1, 1, 1),
+                                        parent=c.scene)
+
+        assert_image_approved(c.render(), 'visuals/rectpolygon3.png')
+
+        rectpolygon.parent = None
+        rectpolygon = visuals.Rectangle(center=(50, 50, 0), height=40.,
+                                        width=80., radius=10.,
+                                        border_color='white',
+                                        parent=c.scene)
+
+        assert_image_approved(c.render(), 'visuals/rectpolygon4.png',
+                              min_corr=0.5)
+
+        rectpolygon.parent = None
+        rectpolygon = visuals.Rectangle(center=(50, 50, 0), height=60.,
+                                        width=80., radius=[25, 10, 0, 15],
+                                        color='red', border_color=(0, 1, 1, 1),
+                                        parent=c.scene)
+
+        assert_image_approved(c.render(), 'visuals/rectpolygon5.png')
+
+        rectpolygon.parent = None
+        rectpolygon = visuals.Rectangle(center=(50, 50, 0), height=60.,
+                                        width=80., radius=[25, 10, 0, 15],
+                                        color='red', border_color=(0, 1, 1, 1),
+                                        border_width=5, border_method='agg',
+                                        parent=c.scene)
+
+        assert_image_approved(c.render(), 'visuals/rectpolygon10.png')
+
+
+@requires_application()
+def test_rectpolygon_draw():
+    """Test drawing transformed rectpolygons using RectPolygonVisual"""
+    with TestingCanvas() as c:
+        rectpolygon = visuals.Rectangle(center=(0., 0.), height=20.,
+                                        width=20., radius=10., color='blue',
+                                        parent=c.scene)
+        rectpolygon.transform = transforms.STTransform(scale=(2.0, 3.0),
+                                                       translate=(50, 50))
+
+        assert_image_approved(c.render(), 'visuals/rectpolygon6.png')
+
+        rectpolygon.parent = None
+        rectpolygon = visuals.Rectangle(center=(0., 0.), height=20.,
+                                        width=20., radius=10.,
+                                        color='blue', border_color='red',
+                                        parent=c.scene)
+        rectpolygon.transform = transforms.STTransform(scale=(2.0, 3.0),
+                                                       translate=(50, 50))
+
+        assert_image_approved(c.render(), 'visuals/rectpolygon7.png')
+
+        rectpolygon.parent = None
+        rectpolygon = visuals.Rectangle(center=(0., 0.), height=60.,
+                                        width=60., radius=10.,
+                                        border_color='red',
+                                        parent=c.scene)
+        rectpolygon.transform = transforms.STTransform(scale=(1.5, 0.5),
+                                                       translate=(50, 50))
+
+        assert_image_approved(c.render(), 'visuals/rectpolygon8.png',
+                              min_corr=0.5)
+
+        rectpolygon.parent = None
+        rectpolygon = visuals.Rectangle(center=(0., 0.), height=60.,
+                                        width=60., radius=[25, 10, 0, 15],
+                                        color='blue', border_color='red',
+                                        parent=c.scene)
+        rectpolygon.transform = transforms.STTransform(scale=(1.5, 0.5),
+                                                       translate=(50, 50))
+
+        assert_image_approved(c.render(), 'visuals/rectpolygon9.png')
+
+
+@requires_application()
+def test_reactive_draw():
+    """Test reactive RectPolygon attributes"""
+    with TestingCanvas() as c:
+        rectpolygon = visuals.Rectangle(center=(50, 50, 0), height=40.,
+                                        width=80., color='red',
+                                        parent=c.scene)
+
+        rectpolygon.radius = [20., 20, 0., 10.]
+
+        assert_image_approved(c.render(),
+                              'visuals/reactive_rectpolygon1.png')
+
+        rectpolygon.center = (60, 60, 0)
+
+        assert_image_approved(c.render(),
+                              'visuals/reactive_rectpolygon2.png')
+
+        rectpolygon.color = 'blue'
+
+        assert_image_approved(c.render(),
+                              'visuals/reactive_rectpolygon3.png')
+
+        rectpolygon.border_color = 'yellow'
+
+        assert_image_approved(c.render(),
+                              'visuals/reactive_rectpolygon4.png')
+
+        rectpolygon.radius = 10.
+
+        assert_image_approved(c.render(),
+                              'visuals/reactive_rectpolygon5.png')
+
+
+@requires_application()
+def test_attributes():
+    """Test if attribute checks are in place"""
+    with TestingCanvas() as c:
+        rectpolygon = visuals.Rectangle(center=(50, 50, 0), height=40.,
+                                        width=80., color='red',
+                                        parent=c.scene)
+        with raises(ValueError):
+            rectpolygon.height = 0
+        with raises(ValueError):
+            rectpolygon.width = 0
+        with raises(ValueError):
+            rectpolygon.radius = [10, 0, 5]
+        with raises(ValueError):
+            rectpolygon.radius = [10.]
+        with raises(ValueError):
+            rectpolygon.radius = 21.
+
+
+run_tests_if_main()

vispy/visuals/tests/test_regular_polygon.py

@@ -0,0 +1,111 @@
+# -*- 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 RegularPolygonVisual
+All images are of size (100,100) to keep a small file size
+"""
+
+from vispy.scene import visuals, transforms
+from vispy.testing import (requires_application, TestingCanvas,
+                           run_tests_if_main)
+from vispy.testing.image_tester import assert_image_approved
+
+
+@requires_application()
+def test_regular_polygon_draw1():
+    """Test drawing regular polygons without transforms using RegularPolygonVisual"""  # noqa
+    with TestingCanvas() as c:
+        rpolygon = visuals.RegularPolygon(center=(0., 0.), radius=0.4, sides=8,
+                                          color=(1, 0, 0, 1),
+                                          parent=c.scene)
+
+        rpolygon.transform = transforms.STTransform(scale=(50, 50),
+                                                    translate=(50, 50))
+        assert_image_approved(c.render(), 'visuals/regular_polygon1.png')
+
+        rpolygon.parent = None
+        rpolygon = visuals.RegularPolygon(center=(0., 0.), radius=0.4, sides=8,
+                                          color=(1, 0, 0, 1),
+                                          border_color=(0, 1, 1, 1),
+                                          parent=c.scene)
+
+        rpolygon.transform = transforms.STTransform(scale=(50, 50),
+                                                    translate=(50, 50))
+        assert_image_approved(c.render(), 'visuals/regular_polygon2.png')
+
+        rpolygon.parent = None
+        rpolygon = visuals.RegularPolygon(center=(0., 0.), radius=0.4, sides=8,
+                                          border_color=(0, 1, 1, 1),
+                                          parent=c.scene)
+
+        rpolygon.transform = transforms.STTransform(scale=(50, 50),
+                                                    translate=(50, 50))
+        assert_image_approved(c.render(), 'visuals/regular_polygon3.png',
+                              min_corr=0.7)
+
+
+@requires_application()
+def test_regular_polygon_draw2():
+    """Test drawing transformed regular polygons using RegularPolygonVisual"""  # noqa
+    with TestingCanvas() as c:
+        rpolygon = visuals.RegularPolygon(center=(0., 0.), radius=0.4, sides=8,
+                                          color=(0, 0, 1, 1),
+                                          parent=c.scene)
+
+        rpolygon.transform = transforms.STTransform(scale=(75, 100),
+                                                    translate=(50, 50))
+        assert_image_approved(c.render(), 'visuals/regular_polygon4.png')
+
+        rpolygon.parent = None
+        rpolygon = visuals.RegularPolygon(center=(0., 0.), radius=0.4, sides=8,
+                                          color=(0, 0, 1, 1),
+                                          border_color=(1, 0, 0, 1),
+                                          parent=c.scene)
+
+        rpolygon.transform = transforms.STTransform(scale=(75, 100),
+                                                    translate=(50, 50))
+        assert_image_approved(c.render(), 'visuals/regular_polygon5.png')
+        rpolygon.parent = None
+        rpolygon = visuals.RegularPolygon(center=(0., 0.), radius=0.4, sides=8,
+                                          border_color=(1, 0, 0, 1),
+                                          parent=c.scene)
+
+        rpolygon.transform = transforms.STTransform(scale=(75, 100),
+                                                    translate=(50, 50))
+        assert_image_approved(c.render(), 'visuals/regular_polygon6.png',
+                              min_corr=0.6)
+
+
+@requires_application()
+def test_reactive_draw():
+    """Test reactive regular polygon attributes"""
+    with TestingCanvas() as c:
+        rpolygon = visuals.RegularPolygon(center=[50, 50, 0.], radius=20,
+                                          sides=8,
+                                          color='yellow',
+                                          parent=c.scene)
+
+        rpolygon.center = [70, 40, 0.]
+        assert_image_approved(c.render(),
+                              'visuals/reactive_regular_polygon1.png')
+
+        rpolygon.radius = 25
+        assert_image_approved(c.render(),
+                              'visuals/reactive_regular_polygon2.png')
+
+        rpolygon.color = 'red'
+        assert_image_approved(c.render(),
+                              'visuals/reactive_regular_polygon3.png')
+
+        rpolygon.border_color = 'yellow'
+        assert_image_approved(c.render(),
+                              'visuals/reactive_regular_polygon4.png')
+
+        rpolygon.sides = 6
+        assert_image_approved(c.render(),
+                              'visuals/reactive_regular_polygon5.png')
+
+
+run_tests_if_main()