vispy 0.14.0__cp311-cp311-macosx_11_0_arm64.whl

vispy/visuals/surface_plot.py

@@ -0,0 +1,192 @@
+# -*- coding: utf-8 -*-
+# Copyright (c) Vispy Development Team. All Rights Reserved.
+# Distributed under the (new) BSD License. See LICENSE.txt for more info.
+
+from __future__ import division
+
+import numpy as np
+
+from .mesh import MeshVisual
+from ..geometry import MeshData
+
+
+class SurfacePlotVisual(MeshVisual):
+    """Displays a surface plot on a regular x,y grid
+
+    Parameters
+    ----------
+    x : ndarray | None
+        1D/2D array of values specifying the x positions of vertices in the
+        grid. In case 1D array given as input, the values will be replicated
+        to fill the 2D array of size(z). If None, values will be assumed to
+        be integers.
+    y : ndarray | None
+        1D/2D array of values specifying the y positions of vertices in the
+        grid. In case 1D array given as input, the values will be replicated
+        to fill the 2D array of size(z). If None, values will be assumed to
+        be integers.
+    z : ndarray
+        2D array of height values for each grid vertex.
+    colors : ndarray
+        (width, height, 4) array of vertex colors.
+
+    Notes
+    -----
+    All arguments are optional.
+
+    Note that if vertex positions are updated, the normal vectors for each
+    triangle must be recomputed. This is somewhat expensive if the surface
+    was initialized with smooth=False and very expensive if smooth=True.
+    For faster performance, initialize with compute_normals=False and use
+    per-vertex colors or a material that does not require normals.
+    """
+
+    def __init__(self, x=None, y=None, z=None, colors=None, **kwargs):
+        # The x, y, z, and colors arguments are passed to set_data().
+        # All other keyword arguments are passed to MeshVisual.__init__().
+        self._x = None
+        self._y = None
+        self._z = None
+        self.__vertices = None
+        self.__faces = None
+        self.__meshdata = MeshData()
+        kwargs.setdefault('shading', 'smooth')
+        MeshVisual.__init__(self, **kwargs)
+        self.set_data(x, y, z, colors)
+
+    def _update_x_data(self, x):
+        if x is not None:
+            if self._x is None or len(x) != len(self._x):
+                self.__vertices = None
+            self._x = x
+
+    def _update_y_data(self, y):
+        if y is not None:
+            if self._y is None or len(y) != len(self._y):
+                self.__vertices = None
+            self._y = y
+
+    def _update_z_data(self, z):
+        if z is not None:
+            if self._x is not None and z.shape[0] != len(self._x):
+                raise TypeError('Z values must have shape (len(x), len(y))')
+            if self._y is not None and z.shape[1] != len(self._y):
+                raise TypeError('Z values must have shape (len(x), len(y))')
+            self._z = z
+            if (self.__vertices is not None and
+                    self._z.shape != self.__vertices.shape[:2]):
+                self.__vertices = None
+
+    def _update_mesh_vertices(self, x_is_new, y_is_new, z_is_new):
+        new_vertices = False
+        update_vertices = False
+        update_faces = False
+
+        # Generate vertex and face array
+        if self.__vertices is None:
+            self.__vertices = np.empty((self._z.shape[0], self._z.shape[1], 3),
+                                       dtype=np.float32)
+            self.__faces = self._generate_faces()
+            new_vertices = True
+            update_faces = True
+
+        # Copy x, y, z data into vertex array
+        if new_vertices or x_is_new:
+            if not x_is_new and self._x is None:
+                x = np.arange(self._z.shape[0])
+            else:
+                x = self._x
+            if x.ndim == 1:
+                x = x.reshape(len(x), 1)
+            # Copy the 2D data into the appropriate slice
+            self.__vertices[:, :, 0] = x
+            update_vertices = True
+
+        if new_vertices or y_is_new:
+            if not y_is_new and self._y is None:
+                y = np.arange(self._z.shape[1])
+            else:
+                y = self._y
+            if y.ndim == 1:
+                y = y.reshape(1, len(y))
+            # Copy the 2D data into the appropriate slice
+            self.__vertices[:, :, 1] = y
+            update_vertices = True
+
+        if new_vertices or z_is_new:
+            self.__vertices[..., 2] = self._z
+            update_vertices = True
+        return update_faces, update_vertices
+
+    def _prepare_mesh_colors(self, colors):
+        if colors is None:
+            return
+        colors = np.asarray(colors)
+        if colors.ndim == 3:
+            # convert (width, height, 4) to (num_verts, 4)
+            vert_shape = self.__vertices.shape
+            num_vertices = vert_shape[0] * vert_shape[1]
+            colors = colors.reshape(num_vertices, 3)
+        return colors
+
+    def set_data(self, x=None, y=None, z=None, colors=None):
+        """Update the data in this surface plot.
+
+        Parameters
+        ----------
+        x : ndarray | None
+            1D/2D array of values specifying the x positions of vertices in
+            the grid. In case 1D array given as input, the values will be
+            replicated to fill the 2D array of size(z). If None, values will be
+            assumed to be integers.
+        y : ndarray | None
+            1D/2D array of values specifying the x positions of vertices in
+            the grid. In case 1D array given as input, the values will be
+            replicated to fill the 2D array of size(z). If None, values will be
+            assumed to be integers.
+        z : ndarray
+            2D array of height values for each grid vertex.
+        colors : ndarray
+            (width, height, 4) array of vertex colors.
+        """
+        self._update_x_data(x)
+        self._update_y_data(y)
+        self._update_z_data(z)
+
+        if self._z is None:
+            # no mesh data to plot so no need to update
+            return
+
+        update_faces, update_vertices = self._update_mesh_vertices(
+            x is not None,
+            y is not None,
+            z is not None
+        )
+
+        colors = self._prepare_mesh_colors(colors)
+        update_colors = colors is not None
+        if update_colors:
+            self.__meshdata.set_vertex_colors(colors)
+        if update_faces:
+            self.__meshdata.set_faces(self.__faces)
+        if update_vertices:
+            self.__meshdata.set_vertices(
+                self.__vertices.reshape(self.__vertices.shape[0] *
+                                        self.__vertices.shape[1], 3))
+        if update_faces or update_vertices or update_colors:
+            MeshVisual.set_data(self, meshdata=self.__meshdata)
+
+    def _generate_faces(self):
+        cols = self._z.shape[1] - 1
+        rows = self._z.shape[0] - 1
+        faces = np.empty((cols * rows * 2, 3), dtype=np.uint)
+        rowtemplate1 = (np.arange(cols).reshape(cols, 1) +
+                        np.array([[0, 1, cols + 1]]))
+        rowtemplate2 = (np.arange(cols).reshape(cols, 1) +
+                        np.array([[cols + 1, 1, cols + 2]]))
+        for row in range(rows):
+            start = row * cols * 2
+            faces[start:start + cols] = rowtemplate1 + row * (cols + 1)
+            faces[start + cols:start + (cols * 2)] =\
+                rowtemplate2 + row * (cols + 1)
+        return faces

vispy/visuals/tests/test_arrows.py

@@ -0,0 +1,109 @@
+# -*- coding: utf-8 -*-
+# Copyright (c) Vispy Development Team. All Rights Reserved.
+# Distributed under the (new) BSD License. See LICENSE.txt for more info.
+
+import numpy as np
+
+from vispy.visuals.line.arrow import ARROW_TYPES
+from vispy.scene import visuals, transforms
+from vispy.testing import (requires_application, TestingCanvas,
+                           run_tests_if_main, assert_raises, SkipTest, IS_TRAVIS_CI)
+from vispy.testing.image_tester import assert_image_approved
+
+
+vertices = np.array([
+    [25, 25],
+    [25, 75],
+    [50, 25],
+    [50, 75],
+    [75, 25],
+    [75, 75]
+]).astype(np.float32)
+
+vertices += 0.33
+
+arrows = np.array([
+    vertices[:2],
+    vertices[3:1:-1],
+    vertices[4:],
+    vertices[-1:-3:-1]
+]).reshape((4, 4))
+
+
+@requires_application()
+def test_arrow_draw():
+    """Test drawing arrows without transforms"""
+    with TestingCanvas() as c:
+        if IS_TRAVIS_CI and c.app.backend_name.lower() == 'pyqt4':
+            # TODO: Fix this (issue #1042
+            raise SkipTest('Travis fails due to FB stack problem')
+        for arrow_type in ARROW_TYPES:
+            arrow = visuals.Arrow(pos=vertices, arrow_type=arrow_type,
+                                  arrows=arrows, arrow_size=10, color='red',
+                                  connect="segments", parent=c.scene)
+
+            assert_image_approved(c.render(), 'visuals/arrow_type_%s.png' %
+                                  arrow_type)
+
+            arrow.parent = None
+
+
+@requires_application()
+def test_arrow_transform_draw():
+    """Tests the ArrowVisual when a transform is applied"""
+    with TestingCanvas() as c:
+        if IS_TRAVIS_CI and c.app.backend_name.lower() == 'pyqt4':
+            # TODO: Fix this (issue #1042
+            raise SkipTest('Travis fails due to FB stack problem')
+        for arrow_type in ARROW_TYPES:
+            arrow = visuals.Arrow(pos=vertices, arrow_type=arrow_type,
+                                  arrows=arrows, arrow_size=10, color='red',
+                                  connect="segments", parent=c.scene)
+            arrow.transform = transforms.STTransform(scale=(0.5, 0.75),
+                                                     translate=(-20, -20))
+
+            assert_image_approved(c.render(),
+                                  'visuals/arrow_transform_type_%s.png' %
+                                  arrow_type)
+
+            arrow.parent = None
+
+
+@requires_application()
+def test_arrow_reactive():
+    """Tests the reactive behaviour of the ArrowVisual properties."""
+    with TestingCanvas() as c:
+        arrow = visuals.Arrow(pos=vertices, arrows=arrows,
+                              connect="segments", parent=c.scene)
+
+        arrow.arrow_type = "stealth"
+        assert_image_approved(c.render(), 'visuals/arrow_reactive1.png')
+
+        arrow.arrow_size = 20
+        assert_image_approved(c.render(), 'visuals/arrow_reactive2.png')
+
+
+@requires_application()
+def test_arrow_attributes():
+    """Tests if the ArrowVisual performs the required checks for attributes."""
+    with TestingCanvas() as c:
+        arrow = visuals.Arrow(pos=vertices, arrow_type="stealth",
+                              arrows=arrows, arrow_size=10, color='red',
+                              connect="segments", parent=c.scene)
+
+        def size_test():
+            arrow.arrow_size = 0.0
+
+        def type_test():
+            arrow.arrow_type = "random_non_existent"
+
+        assert_raises(
+            ValueError, size_test
+        )
+
+        assert_raises(
+            ValueError, type_test
+        )
+
+
+run_tests_if_main()

vispy/visuals/tests/test_axis.py

@@ -0,0 +1,120 @@
+# -*- 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 AxisVisual"""
+
+from numpy.testing import assert_allclose, assert_array_equal
+
+from vispy import scene
+from vispy.scene import visuals
+from vispy.testing import (requires_application, TestingCanvas,
+                           run_tests_if_main)
+
+
+@requires_application()
+def test_axis():
+    with TestingCanvas() as c:
+        axis = visuals.Axis(pos=[[-1.0, 0], [1.0, 0]], parent=c.scene)
+        c.draw_visual(axis)
+
+
+@requires_application()
+def test_axis_zero_domain():
+    # Regression test for a bug that caused an overflow error when the domain
+    # min was same as max
+    with TestingCanvas() as c:
+        axis = visuals.Axis(pos=[[-1.0, 0], [1.0, 0]], domain=(0.5, 0.5), parent=c.scene)
+        c.draw_visual(axis)
+
+
+@requires_application()
+def test_rotation_angle():
+
+    # Make sure the rotation angle calculation is correct
+
+    canvas = scene.SceneCanvas(keys=None, size=(800, 600), show=True)
+    view = canvas.central_widget.add_view()
+    view.camera = scene.cameras.TurntableCamera(parent=view.scene,
+                                                fov=0., distance=4.0,
+                                                elevation=0, azimuth=0, roll=0.)
+
+    axis1 = visuals.Axis(pos=[[-1.0, 0], [1.0, 0]], parent=view.scene)
+    assert_allclose(axis1._rotation_angle, 0)
+
+    axis2 = visuals.Axis(pos=[[-3**0.5/2., -0.5], [3**0.5/2., 0.5]], parent=view.scene)
+    assert_allclose(axis2._rotation_angle, 0.)
+
+    view.camera.elevation = 90.
+
+    assert_allclose(axis1._rotation_angle, 0)
+    assert_allclose(axis2._rotation_angle, -30, rtol=1e-3)
+
+    view.camera.elevation = 45.
+
+    assert_allclose(axis1._rotation_angle, 0)
+    assert_allclose(axis2._rotation_angle, -22.207653, rtol=1e-3)
+
+    view.camera.fov = 20.
+
+    assert_allclose(axis1._rotation_angle, 0)
+    # OSX Travis has some small differences...sometimes
+    assert_allclose(axis2._rotation_angle, -17.056795, rtol=0.05)
+
+
+@requires_application()
+def test_text_position():
+
+    # Test the labels text and position of the axis depending on its domain
+
+    canvas = scene.SceneCanvas(keys=None, size=(800, 600), show=True)
+    view = canvas.central_widget.add_view()
+    view.camera = scene.cameras.PanZoomCamera(parent=view.scene)
+
+    # tick length and label margin to 0 for nice values
+    axis1 = visuals.Axis(pos=[[-1.0, 0], [1.0, 0]], domain=(0., 1.25), 
+                         major_tick_length=0, tick_label_margin=0, 
+                         parent=view.scene)
+
+    canvas.draw_visual(axis1)
+    assert_allclose(axis1._text.pos[:, 0], (-1, -0.2, 0.6))
+    assert_array_equal(axis1._text.text, ('0', '0.5', '1'))
+
+    # Flip the axis domain
+    axis1.domain = (1.25, 0.)
+    canvas.draw_visual(axis1)
+    # Text should be unchanged and positions mirrored
+    assert_allclose(axis1._text.pos[:, 0], (1, 0.2, -0.6))
+    assert_array_equal(axis1._text.text, ('0', '0.5', '1'))
+
+
+@requires_application()
+def test_tick_position():
+
+    # Test the position of the ticks depending on the axis domain
+
+    canvas = scene.SceneCanvas(keys=None, size=(800, 600), show=True)
+    view = canvas.central_widget.add_view()
+    view.camera = scene.cameras.PanZoomCamera(parent=view.scene)
+
+    axis1 = visuals.Axis(pos=[[-1.0, 0], [1.0, 0]], domain=(0., 1.25), parent=view.scene)
+
+    canvas.draw_visual(axis1)
+    # Get a nice array of x ticks positions
+    x_ticks_positions = axis1._ticks.pos[::2, ::2].flatten()
+    # Compare major ticks first
+    assert_allclose(x_ticks_positions[:3], (-1, -0.2, 0.6))
+    # Then minor ticks
+    assert_allclose(x_ticks_positions[3:], (-0.84, -0.68, -0.52, -0.36, -0.04, 0.12, 0.28, 0.44, 0.76, 0.92))
+
+    # Flip the axis domain
+    axis1.domain = (1.25, 0.)
+    canvas.draw_visual(axis1)
+    x_ticks_positions = axis1._ticks.pos[::2, ::2].flatten()
+    # Positions should be mirrored
+    assert_allclose(x_ticks_positions[:3], (1, 0.2, -0.6))
+    assert_allclose(x_ticks_positions[3:], (0.84, 0.68, 0.52, 0.36, 0.04, -0.12, -0.28, -0.44, -0.76, -0.92))
+
+run_tests_if_main()

vispy/visuals/tests/test_collections.py

@@ -0,0 +1,15 @@
+# *Very* basic collections tests
+
+from vispy.visuals.collections import (PathCollection, PointCollection,
+                                       PolygonCollection, SegmentCollection,
+                                       TriangleCollection)
+from vispy.testing import requires_application, TestingCanvas
+
+
+@requires_application()
+def test_init():
+    """Test collection initialization"""
+    with TestingCanvas():
+        for coll in (PathCollection, PointCollection, PolygonCollection,
+                     SegmentCollection, TriangleCollection):
+            coll()

vispy/visuals/tests/test_colorbar.py

@@ -0,0 +1,179 @@
+# -*- coding: utf-8 -*-
+
+"""
+Tests for ColorbarVisual
+All images are of size (100,100) to keep a small file size
+"""
+
+from vispy.scene import visuals
+from vispy.testing import (requires_application, TestingCanvas,
+                           run_tests_if_main, raises)
+from vispy.testing.image_tester import assert_image_approved
+
+
+def create_colorbar(pos, size, orientation, label='label string here'):
+    colorbar = visuals.ColorBar(pos=pos,
+                                size=size,
+                                orientation=orientation,
+                                label=label,
+                                cmap='autumn',
+                                border_color='white',
+                                border_width=2)
+
+    colorbar.label.color = 'white'
+    colorbar.label.font_size = 5
+
+    colorbar.ticks[0].color = 'white'
+    colorbar.ticks[0].font_size = 5
+
+    colorbar.ticks[1].color = 'white'
+    colorbar.ticks[1].font_size = 5
+
+    return colorbar
+
+
+@requires_application()
+def test_colorbar_draw():
+    """Test drawing Colorbar without transform using ColorbarVisual"""
+    with TestingCanvas() as c:
+        colorbar_top = create_colorbar(pos=(50, 50),
+                                       size=(60, 4),
+                                       orientation='top')
+
+        c.draw_visual(colorbar_top)
+        assert_image_approved(c.render(), 'visuals/colorbar/top.png')
+        colorbar_top.parent = None
+
+        colorbar_bottom = create_colorbar(pos=(50, 50),
+                                          size=(60, 4),
+                                          orientation='bottom')
+
+        c.draw_visual(colorbar_bottom)
+        assert_image_approved(c.render(), 'visuals/colorbar/bottom.png')
+        colorbar_bottom.parent = None
+
+        colorbar_left = create_colorbar(pos=(50, 50),
+                                        size=(60, 4),
+                                        orientation='left')
+
+        c.draw_visual(colorbar_left)
+        assert_image_approved(c.render(), 'visuals/colorbar/left.png')
+        colorbar_left.parent = None
+
+        colorbar_right = create_colorbar(pos=(50, 50),
+                                         size=(60, 4),
+                                         orientation='right')
+
+        c.draw_visual(colorbar_right)
+        assert_image_approved(c.render(), 'visuals/colorbar/right.png')
+
+
+@requires_application()
+def test_reactive_draw():
+    """Test reactive RectPolygon attributes"""
+    with TestingCanvas() as c:
+        colorbar = create_colorbar(pos=(50, 50),
+                                   size=(60, 4),
+                                   orientation='top')
+        c.draw_visual(colorbar)
+
+        colorbar.cmap = "ice"
+        assert_image_approved(c.render(),
+                              'visuals/colorbar/reactive_cmap.png')
+
+        colorbar.clim = (-20, 20)
+        assert_image_approved(c.render(),
+                              'visuals/colorbar/reactive_clim.png')
+
+        colorbar.label.text = "new label"
+        assert_image_approved(c.render(),
+                              'visuals/colorbar/reactive_label.png')
+
+        colorbar.ticks[0].color = "red"
+        colorbar.ticks[1].color = "blue"
+        assert_image_approved(c.render(),
+                              'visuals/colorbar/reactive_ticks.png')
+
+        colorbar.border_width = 0
+        assert_image_approved(c.render(),
+                              'visuals/colorbar/reactive_border_width.png')
+
+        colorbar.border_width = 5
+        colorbar.border_color = "red"
+        assert_image_approved(c.render(),
+                              'visuals/colorbar/reactive_border_color.png')
+
+
+@requires_application()
+def test_attributes():
+    """Test if attribute checks are in place"""
+    with TestingCanvas():
+
+        # initialize with major axis < minor axis
+        with raises(ValueError):
+            create_colorbar(pos=(50, 50),
+                            size=(1, 30),
+                            orientation='top')
+
+        # set major axis to 0
+        with raises(ValueError):
+            create_colorbar(pos=(50, 50),
+                            size=(0, 1),
+                            orientation='right')
+
+        # set negative major axis
+        with raises(ValueError):
+            create_colorbar(pos=(50, 50),
+                            size=(-10, 1),
+                            orientation='right')
+
+        # set negative minor axis
+        with raises(ValueError):
+            create_colorbar(pos=(50, 50),
+                            size=(1, -10),
+                            orientation='right')
+
+        # set minor axis to 0
+        with raises(ValueError):
+            create_colorbar(pos=(50, 50),
+                            size=(1, 0),
+                            orientation='right')
+
+        # set invalid orientation
+        with raises(ValueError):
+            create_colorbar(pos=(50, 50),
+                            size=(60, 4),
+                            orientation='top-invalid')
+
+
+@requires_application()
+def test_colorbar_label_change():
+    with TestingCanvas() as c:
+        colorbar = create_colorbar(pos=(50, 50),
+                                   size=(60, 4),
+                                   orientation='top')
+        colorbar.cmap = "ice"
+        orig_text_vis = colorbar.label
+        colorbar.label = "New Label"
+        assert colorbar.label.text == "New Label"
+        assert colorbar.label is orig_text_vis
+
+        c.draw_visual(colorbar)
+
+
+@requires_application()
+def test_colorbar_label_as_textvisual():
+    with TestingCanvas() as c:
+        label = visuals.Text("my label")
+        colorbar = create_colorbar(pos=(50, 50),
+                                   size=(60, 4),
+                                   orientation='top',
+                                   label=label)
+        colorbar.cmap = "ice"
+        assert colorbar.label.text == "my label"
+        assert colorbar.label is label
+
+        c.draw_visual(colorbar)
+
+
+run_tests_if_main()