vispy 0.13.0__cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl → 0.14.0__cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl

vispy/app/backends/_glfw.py

@@ -250,7 +250,7 @@ class CanvasBackend(BaseCanvasBackend):
                     raise ValueError('fullscreen must be <= %s'
                                      % len(monitor))
                 monitor = monitor[p.fullscreen]
-            use_size = glfw.get_video_mode(monitor)[:2]
+            use_size = glfw.get_video_mode(monitor)[0][:2]
             if use_size != tuple(p.size):
                 logger.debug('Requested size %s, will be ignored to '
                              'use fullscreen mode %s' % (p.size, use_size))

vispy/color/colormap.py

@@ -1092,17 +1092,13 @@ _colormaps = dict(
 )
 
 
-def get_colormap(name, *args, **kwargs):
-    """Obtain a colormap.
+def get_colormap(name):
+    """Obtain a colormap by name.
 
     Parameters
     ----------
     name : str | Colormap
         Colormap name. Can also be a Colormap for pass-through.
-    *args:
-        Deprecated.
-    **kwargs
-        Deprecated.
 
     Examples
     --------
@@ -1111,18 +1107,10 @@ def get_colormap(name, *args, **kwargs):
 
     .. versionchanged: 0.7
 
-        Additional args/kwargs are no longer accepted. Colormap classes are
-        no longer created on the fly. To create a ``cubehelix``
-        (``CubeHelixColormap``), ``single_hue`` (``SingleHue``), ``hsl``
-        (``HSL``), ``husl`` (``HSLuv``), ``diverging`` (``Diverging``), or
-        ``RdYeBuCy`` (``RedYellowBlueCyan``) colormap you must import and
-        instantiate it directly from the ``vispy.color.colormap`` module.
+        Additional args/kwargs are no longer accepted. Colormap instances are
+        no longer created on the fly.
 
     """
-    if args or kwargs:
-        warnings.warn("Creating a Colormap instance with 'get_colormap' is "
-                      "no longer supported. No additional arguments or "
-                      "keyword arguments should be passed.", DeprecationWarning)
     if isinstance(name, BaseColormap):
         return name
 
@@ -1130,14 +1118,6 @@ def get_colormap(name, *args, **kwargs):
         raise TypeError('colormap must be a Colormap or string name')
     if name in _colormaps:  # vispy cmap
         cmap = _colormaps[name]
-        if name in ("cubehelix", "single_hue", "hsl", "husl", "diverging", "RdYeBuCy"):
-            warnings.warn(
-                f"Colormap '{name}' has been deprecated since vispy 0.7. "
-                f"Please import and create 'vispy.color.colormap.{cmap.__class__.__name__}' "
-                "directly instead.",
-                DeprecationWarning,
-                stacklevel=2,
-            )
 
     elif has_matplotlib():  # matplotlib cmap
         try:

vispy/gloo/texture.py

@@ -33,7 +33,9 @@ def convert_dtype_and_clip(data, dtype, copy=False):
     else:
         # to reduce copying, we clip into a pre-generated array of the right dtype
         new_data = np.empty_like(data, dtype=dtype)
-        np.clip(data, new_min, new_max, out=new_data)
+        # allow "unsafe" casting here as we're explicitly clipping to the
+        # range of the new dtype - this was a default before numpy 1.25
+        np.clip(data, new_min, new_max, out=new_data, casting="unsafe")
         return new_data
 
 

vispy/scene/canvas.py

@@ -493,11 +493,8 @@ class SceneCanvas(app.Canvas, Frozen):
             than triggering transform updates across the scene with every
             click.
         """
-        try:
-            self._scene.picking = True
+        with self._scene.set_picking():
             img = self.render(bgcolor=(0, 0, 0, 0), crop=crop)
-        finally:
-            self._scene.picking = False
         img = img.astype('int32') * [2**0, 2**8, 2**16, 2**24]
         id_ = img.sum(axis=2).astype('int32')
         return id_

vispy/scene/node.py

@@ -5,6 +5,7 @@
 from __future__ import division
 
 import weakref
+from contextlib import contextmanager
 
 from ..util.event import Event, EmitterGroup
 from ..visuals.transforms import (NullTransform, BaseTransform, 
@@ -626,3 +627,18 @@ class Node(object):
         for c in self.children:
             c.picking = p
         self._picking = p
+
+    @contextmanager
+    def set_picking(self, *, picking=True):
+        """Context manager to temporarily set picking for this node and its children.
+
+        Note that this function will not alter the picking mode unless/until
+        the context manager is entered (using the `with` statement). Use
+        :py:attr:`~.picking` for setting the picking mode directly.
+        """
+        old_picking = self.picking
+        try:
+            self.picking = picking
+            yield self.picking
+        finally:
+            self.picking = old_picking

vispy/scene/tests/test_visuals.py

@@ -1,3 +1,5 @@
+import pytest
+
 from vispy.scene import visuals, Node
 from vispy.scene.visuals import VisualNode
 import vispy.visuals
@@ -26,3 +28,114 @@ def test_visual_node_generation():
             vis_node = getattr(visuals, name[:-6])
             assert issubclass(vis_node, Node)
             assert issubclass(vis_node, obj)
+
+
+def test_push_gl_state():
+    node = vispy.visuals.MeshVisual()
+    og_gl_state = node._vshare.gl_state.copy()
+    node.push_gl_state(blend=False, depth_test=False)
+    assert node._vshare.gl_state != og_gl_state
+    # preset is always set, unset kwargs should be absent
+    assert node._vshare.gl_state == {
+        "preset": None,
+        "blend": False,
+        "depth_test": False,
+    }
+    node.pop_gl_state()
+    assert node._vshare.gl_state == og_gl_state
+
+
+def test_push_gl_state_update():
+    node = vispy.visuals.MeshVisual()
+    og_gl_state = node._vshare.gl_state.copy()
+    assert "blend" not in og_gl_state
+    assert node._vshare.gl_state["depth_test"]
+
+    node.push_gl_state_update(blend=False, depth_test=False)
+    assert node._vshare.gl_state != og_gl_state
+    assert not node._vshare.gl_state["blend"]
+    assert not node._vshare.gl_state["depth_test"]
+
+    node.pop_gl_state()
+    assert node._vshare.gl_state == og_gl_state
+
+
+def test_pop_empty_gl_state():
+    node = vispy.visuals.MeshVisual()
+    assert node._prev_gl_state == []
+    og_gl_state = node._vshare.gl_state.copy()
+    node.pop_gl_state()
+    assert node._vshare.gl_state == og_gl_state
+
+
+def test_update_gl_state():
+    node = vispy.visuals.MeshVisual()
+
+    og_gl_state = node._vshare.gl_state.copy()
+    assert og_gl_state
+    og_gl_state["blend"] = False
+
+    node.update_gl_state(blend=True)
+
+    # check that the state was updated
+    assert node._vshare.gl_state.pop("blend") != og_gl_state.pop("blend")
+    # the rest of the state should be unchanged
+    assert node._vshare.gl_state == og_gl_state
+
+
+def test_update_gl_state_context_manager():
+    node = vispy.visuals.MeshVisual()
+
+    node.set_gl_state(blend=False)
+    og_gl_state = node._vshare.gl_state.copy()
+
+    with node.update_gl_state(blend=True):
+        # check that the state was updated
+        assert node._vshare.gl_state == {**og_gl_state, "blend": True}
+
+    # the update should be reverted once out of the context
+    assert node._vshare.gl_state == og_gl_state
+
+
+def test_set_gl_state():
+    node = vispy.visuals.MeshVisual()
+
+    node.set_gl_state(blend=False, depth_test=False)
+    # preset is always set, unset kwargs should be absent
+    assert node._vshare.gl_state == {
+        "preset": None,
+        "blend": False,
+        "depth_test": False,
+    }
+
+    node.set_gl_state(blend=False)
+    # preset is always set, unset kwargs should be absent
+    assert node._vshare.gl_state == {"preset": None, "blend": False}
+
+
+def test_set_gl_state_context_manager():
+    node = vispy.visuals.MeshVisual()
+
+    node.set_gl_state(blend=False)
+    og_gl_state = node._vshare.gl_state.copy()
+
+    with node.set_gl_state(blend=True):
+        # preset is always set, unset kwargs should be absent
+        assert node._vshare.gl_state == {"preset": None, "blend": True}
+
+    # the update should be reverted once out of the context
+    assert node._vshare.gl_state == og_gl_state
+
+
+@pytest.mark.parametrize("enable_picking", [True, False])
+def test_picking_context(enable_picking):
+    mesh = visuals.Mesh()
+    mesh.picking = not enable_picking
+
+    assert mesh.picking != enable_picking
+
+    with mesh.set_picking(picking=enable_picking) as p:
+        assert p == enable_picking
+        assert mesh.picking == enable_picking
+
+    assert mesh.picking != enable_picking

vispy/scene/visuals.py

@@ -71,7 +71,10 @@ class VisualNode(Node):
             return
         self._picking = p
         self._picking_filter.enabled = p
-        self.update_gl_state(blend=not p)
+        if p:
+            self.push_gl_state_update(blend=False)
+        else:
+            self.pop_gl_state()
 
     def _update_trsys(self, event):
         """Transform object(s) have changed for this Node; assign these to the

vispy/version.py

@@ -1,4 +1,4 @@
 # file generated by setuptools_scm
 # don't change, don't track in version control
-__version__ = version = '0.13.0'
-__version_tuple__ = version_tuple = (0, 13, 0)
+__version__ = version = '0.14.0'
+__version_tuple__ = version_tuple = (0, 14, 0)

vispy/visuals/filters/__init__.py

@@ -2,8 +2,9 @@
 # Copyright (c) Vispy Development Team. All Rights Reserved.
 # Distributed under the (new) BSD License. See LICENSE.txt for more info.
 
-from .base_filter import Filter  # noqa
+from .base_filter import Filter, PrimitivePickingFilter  # noqa
 from .clipper import Clipper  # noqa
 from .color import Alpha, ColorFilter, IsolineFilter, ZColormapFilter  # noqa
 from .picking import PickingFilter  # noqa
-from .mesh import TextureFilter, ShadingFilter, InstancedShadingFilter, WireframeFilter  # noqa
+from .markers import MarkerPickingFilter  # noqa
+from .mesh import TextureFilter, ShadingFilter, InstancedShadingFilter, WireframeFilter, FacePickingFilter  # noqa

vispy/visuals/filters/base_filter.py

@@ -2,6 +2,11 @@
 # Copyright (c) Vispy Development Team. All Rights Reserved.
 # Distributed under the (new) BSD License. See LICENSE.txt for more info.
 
+from abc import ABCMeta, abstractmethod
+
+import numpy as np
+
+from vispy.gloo import VertexBuffer
 from ..shaders import Function
 
 
@@ -120,3 +125,118 @@ class Filter(BaseFilter):
 
         self._attached = False
         self._visual = None
+
+
+class PrimitivePickingFilter(Filter, metaclass=ABCMeta):
+    """Abstract base class for Visual-specific filters to implement a
+    primitive-picking mode.
+
+    Subclasses must (and usually only need to) implement
+    :py:meth:`_get_picking_ids`.
+    """
+
+    def __init__(self, fpos=9, *, discard_transparent=False):
+        # fpos is set to 9 by default to put it near the end, but before the
+        # default PickingFilter
+        vfunc = Function("""\
+            varying vec4 v_marker_picking_color;
+            void prepare_marker_picking() {
+                v_marker_picking_color = $ids;
+            }
+        """)
+        ffunc = Function("""\
+            varying vec4 v_marker_picking_color;
+            void marker_picking_filter() {
+                if ( $enabled != 1 ) {
+                    return;
+                }
+                if ( $discard_transparent == 1 && gl_FragColor.a == 0.0 ) {
+                    discard;
+                }
+                gl_FragColor = v_marker_picking_color;
+            }
+        """)
+
+        self._id_colors = VertexBuffer(np.zeros((0, 4), dtype=np.float32))
+        vfunc['ids'] = self._id_colors
+        self._n_primitives = 0
+        super().__init__(vcode=vfunc, fcode=ffunc, fpos=fpos)
+        self.enabled = False
+        self.discard_transparent = discard_transparent
+
+    @abstractmethod
+    def _get_picking_ids(self):
+        """Return a 1D array of picking IDs for the vertices in the visual.
+
+        Generally, this method should be implemented to:
+            1. Calculate the number of primitives in the visual (may be
+            persisted in `self._n_primitives`).
+            2. Calculate a range of picking ids for each primitive in the
+            visual. IDs should start from 1, reserving 0 for the background. If
+            primitives comprise multiple vertices (triangles), ids may need to
+            be repeated.
+
+        The return value should be an array of uint32 with shape
+        (num_vertices,).
+
+        If no change to the picking IDs is needed (for example, the number of
+        primitives has not changed), this method should return `None`.
+        """
+        raise NotImplementedError(self)
+
+    def _update_id_colors(self):
+        """Calculate the colors encoding the picking IDs for the visual.
+
+        For performance, this method will not update the id colors VertexBuffer
+        if :py:meth:`_get_picking_ids` returns `None`.
+        """
+        # this should remain untouched
+        ids = self._get_picking_ids()
+        if ids is not None:
+            id_colors = self._pack_ids_into_rgba(ids)
+            self._id_colors.set_data(id_colors)
+
+    @staticmethod
+    def _pack_ids_into_rgba(ids):
+        """Pack an array of uint32 primitive ids into float32 RGBA colors."""
+        if ids.dtype != np.uint32:
+            raise ValueError(f"ids must be uint32, got {ids.dtype}")
+
+        return np.divide(
+            ids.view(np.uint8).reshape(-1, 4),
+            255,
+            dtype=np.float32
+        )
+
+    def _on_data_updated(self, event=None):
+        if not self.attached:
+            return
+        self._update_id_colors()
+
+    @property
+    def enabled(self):
+        return self._enabled
+
+    @enabled.setter
+    def enabled(self, e):
+        self._enabled = bool(e)
+        self.fshader['enabled'] = int(self._enabled)
+        self._on_data_updated()
+
+    @property
+    def discard_transparent(self):
+        return self._discard_transparent
+
+    @discard_transparent.setter
+    def discard_transparent(self, d):
+        self._discard_transparent = bool(d)
+        self.fshader['discard_transparent'] = int(self._discard_transparent)
+
+    def _attach(self, visual):
+        super()._attach(visual)
+        visual.events.data_updated.connect(self._on_data_updated)
+        self._on_data_updated()
+
+    def _detach(self, visual):
+        visual.events.data_updated.disconnect(self._on_data_updated)
+        super()._detach(visual)

vispy/visuals/filters/markers.py

@@ -0,0 +1,28 @@
+import numpy as np
+
+from vispy.visuals.filters import PrimitivePickingFilter
+
+
+class MarkerPickingFilter(PrimitivePickingFilter):
+    """Filter used to color markers by a picking ID.
+
+    Note that the ID color uses the alpha channel, so this may not be used
+    with blending enabled.
+
+    Examples
+    --------
+    :ref:`sphx_glr_gallery_scene_marker_picking.py`
+    """
+
+    def _get_picking_ids(self):
+        if self._visual._data is None:
+            n_markers = 0
+        else:
+            n_markers = len(self._visual._data['a_position'])
+
+        # we only care about the number of markers changing
+        if self._n_primitives == n_markers:
+            return
+        self._n_primitives = n_markers
+
+        return np.arange(1, n_markers + 1, dtype=np.uint32)

vispy/visuals/filters/mesh.py

@@ -7,7 +7,7 @@ import numpy as np
 
 from vispy.gloo import Texture2D, VertexBuffer
 from vispy.visuals.shaders import Function, Varying
-from vispy.visuals.filters import Filter
+from vispy.visuals.filters import Filter, PrimitivePickingFilter
 from ...color import Color
 
 
@@ -177,6 +177,7 @@ void shade() {
         vec3 u = dFdx(v_pos_scene.xyz);
         vec3 v = dFdy(v_pos_scene.xyz);
         normal = cross(u, v);
+    } else {
         // Note(asnt): The normal calculated above always points in the
         // direction of the camera. Reintroduce the original orientation of the
         // face.
@@ -756,13 +757,40 @@ class WireframeFilter(Filter):
         bc = np.tile(bc[None, ...], (n_faces, 1, 1))
         self._bc.set_data(bc, convert=True)
 
-    def on_mesh_data_updated(self, event):
+    def on_data_updated(self, event):
         self._update_data()
 
     def _attach(self, visual):
         super()._attach(visual)
-        visual.events.data_updated.connect(self.on_mesh_data_updated)
+        visual.events.data_updated.connect(self.on_data_updated)
 
     def _detach(self, visual):
-        visual.events.data_updated.disconnect(self.on_mesh_data_updated)
+        visual.events.data_updated.disconnect(self.on_data_updated)
         super()._detach(visual)
+
+
+class FacePickingFilter(PrimitivePickingFilter):
+    """Filter used to color mesh faces by a picking ID.
+
+    Note that the ID color uses the alpha channel, so this may not be used
+    with blending enabled.
+
+    Examples
+    --------
+    :ref:`sphx_glr_gallery_scene_face_picking.py`
+    """
+
+    def _get_picking_ids(self):
+        if self._visual.mesh_data.is_empty():
+            n_faces = 0
+        else:
+            n_faces = len(self._visual.mesh_data.get_faces())
+
+        # we only care about the number of faces changing
+        if self._n_primitives == n_faces:
+            return None
+        self._n_primitives = n_faces
+
+        ids = np.arange(1, n_faces + 1, dtype=np.uint32)
+        ids = np.repeat(ids, 3, axis=0)  # repeat id for each vertex
+        return ids

vispy/visuals/filters/tests/test_primitive_picking_filters.py

@@ -0,0 +1,70 @@
+# -*- 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.geometry import create_plane
+from vispy.scene.visuals import Markers, Mesh
+from vispy.testing import requires_application, TestingCanvas
+from vispy.visuals.filters import FacePickingFilter, MarkerPickingFilter
+
+
+def test_empty_mesh_face_picking():
+    mesh = Mesh()
+    filter = FacePickingFilter()
+    mesh.attach(filter)
+    filter.enabled = True
+
+
+@requires_application()
+def test_mesh_face_picking():
+    vertices, faces, _ = create_plane(125, 125)
+    vertices = vertices["position"]
+    vertices[:, :2] += 125 / 2
+    mesh = Mesh(vertices=vertices, faces=faces)
+    filter = FacePickingFilter()
+    mesh.attach(filter)
+
+    with TestingCanvas(size=(125, 125)) as c:
+        view = c.central_widget.add_view()
+        view.add(mesh)
+        filter.enabled = True
+        mesh.update_gl_state(blend=False)
+        picking_render = c.render(bgcolor=(0, 0, 0, 0), alpha=True)
+
+    # unpack the IDs
+    ids = picking_render.view(np.uint32)
+    # the plane is made up of two triangles and nearly fills the view
+    # pick one point on each triangle
+    assert ids[125 // 2, 125 // 4] == 1
+    assert ids[125 // 2, 3 * 125 // 4] == 2
+
+
+def test_empty_markers_picking():
+    markers = Markers()
+    filter = MarkerPickingFilter()
+    markers.attach(filter)
+    filter.enabled = True
+
+
+@requires_application()
+def test_markers_picking():
+    markers = Markers(
+        pos=np.array([[-0.5, -0.5], [0.5, 0.5]]),
+        size=5,
+    )
+    filter = MarkerPickingFilter()
+    markers.attach(filter)
+
+    with TestingCanvas(size=(125, 125)) as c:
+        view = c.central_widget.add_view(camera="panzoom")
+        view.camera.rect = (-1, -1, 2, 2)
+        view.add(markers)
+
+        filter.enabled = True
+        markers.update_gl_state(blend=False)
+        picking_render = c.render(bgcolor=(0, 0, 0, 0), alpha=True)
+        ids = picking_render.view(np.uint32)
+
+        assert ids[3 * 125 // 4, 125 // 4] == 1
+        assert ids[125 // 4, 3 * 125 // 4] == 2

vispy/visuals/line/dash_atlas.py

@@ -2,6 +2,8 @@
 # Copyright (c) Vispy Development Team. All Rights Reserved.
 # Distributed under the (new) BSD License. See LICENSE.txt for more info.
 
+from functools import lru_cache
+
 import numpy as np
 
 
@@ -40,46 +42,49 @@ class DashAtlas(object):
         self._atlas[key] = [self._index / float(self._data.shape[0]), period]
         self._index += 1
         self._dirty = True
-        # self.add_pattern(value)
-
-    def make_pattern(self, pattern, caps=[1, 1]):
-        """ """
-
-        # A pattern is defined as on/off sequence of segments
-        # It must be a multiple of 2
-        if len(pattern) > 1 and len(pattern) % 2:
-            pattern = [pattern[0] + pattern[-1]] + pattern[1:-1]
-        P = np.array(pattern)
-
-        # Period is the sum of all segment length
-        period = np.cumsum(P)[-1]
-
-        # Find all start and end of on-segment only
-        C, c = [], 0
-        for i in range(0, len(P) + 2, 2):
-            a = max(0.0001, P[i % len(P)])
-            b = max(0.0001, P[(i + 1) % len(P)])
-            C.extend([c, c + a])
-            c += a + b
-        C = np.array(C)
-
-        # Build pattern
+
+    def make_pattern(self, pattern, caps=(1, 1)):
         length = self._data.shape[1]
-        Z = np.zeros((length, 4), dtype=np.float32)
-        for i in np.arange(0, len(Z)):
-            x = period * (i) / float(len(Z) - 1)
-            index = np.argmin(abs(C - (x)))
-            if index % 2 == 0:
-                if x <= C[index]:
-                    dash_type = +1
-                else:
-                    dash_type = 0
-                dash_start, dash_end = C[index], C[index + 1]
+        return _make_pattern(length, pattern, caps)
+
+
+@lru_cache(maxsize=32)
+def _make_pattern(length, pattern, caps):
+    """Make a concrete dash pattern of a given length."""
+    # A pattern is defined as on/off sequence of segments
+    # It must be a multiple of 2
+    if len(pattern) > 1 and len(pattern) % 2:
+        pattern = [pattern[0] + pattern[-1]] + pattern[1:-1]
+    P = np.array(pattern)
+
+    # Period is the sum of all segment length
+    period = np.cumsum(P)[-1]
+
+    # Find all start and end of on-segment only
+    C, c = [], 0
+    for i in range(0, len(P) + 2, 2):
+        a = max(0.0001, P[i % len(P)])
+        b = max(0.0001, P[(i + 1) % len(P)])
+        C.extend([c, c + a])
+        c += a + b
+    C = np.array(C)
+
+    # Build pattern
+    Z = np.zeros((length, 4), dtype=np.float32)
+    for i in np.arange(0, len(Z)):
+        x = period * (i) / float(len(Z) - 1)
+        index = np.argmin(abs(C - (x)))
+        if index % 2 == 0:
+            if x <= C[index]:
+                dash_type = +1
+            else:
+                dash_type = 0
+            dash_start, dash_end = C[index], C[index + 1]
+        else:
+            if x > C[index]:
+                dash_type = -1
             else:
-                if x > C[index]:
-                    dash_type = -1
-                else:
-                    dash_type = 0
-                dash_start, dash_end = C[index - 1], C[index]
-            Z[i] = C[index], dash_type, dash_start, dash_end
-        return Z, period
+                dash_type = 0
+            dash_start, dash_end = C[index - 1], C[index]
+        Z[i] = C[index], dash_type, dash_start, dash_end
+    return Z, period