vispy 0.13.0__cp311-cp311-win_amd64.whl → 0.14.0__cp311-cp311-win_amd64.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

vispy/visuals/markers.py

@@ -11,12 +11,13 @@ from ..color import ColorArray
 from ..gloo import VertexBuffer
 from .shaders import Function, Variable
 from .visual import Visual
+from ..util.event import Event
 
 
 _VERTEX_SHADER = """
 uniform float u_antialias;
 uniform float u_px_scale;
-uniform int u_scaling;
+uniform bool u_scaling;
 uniform bool u_spherical;
 
 attribute vec3 a_position;
@@ -48,26 +49,15 @@ void main (void) {
     gl_Position = $framebuffer_to_render(fb_pos);
 
     // NOTE: gl_stuff uses framebuffer coords!
-    if (u_scaling == 1) {
+    if (u_scaling) {
         // scaling == "scene": scale marker using entire visual -> framebuffer set of transforms
-        x = $framebuffer_to_visual(fb_pos + vec4(big_float, 0, 0, 0));
-        x = (x - pos);
-        size_vec = $visual_to_framebuffer(pos + normalize(x) * a_size);
-        $v_size = size_vec.x / size_vec.w - fb_pos.x / fb_pos.w;
-        v_edgewidth = ($v_size / a_size) * a_edgewidth;
-    }
-    else if (u_scaling == 2) {
         // scaling == "visual": scale marker using only the Visual's transform
-        // move horizontally in framebuffer space
-        // then go to scene coordinates (not visual, so scaling is accounted for)
-        x = $framebuffer_to_scene(fb_pos + vec4(big_float, 0, 0, 0));
-        // subtract position, so we get the scene-coordinate vector describing
-        // an "horizontal direction parallel to the screen"
-        vec4 scene_pos = $framebuffer_to_scene(fb_pos);
-        x = (x - scene_pos);
-        // multiply that direction by the size (in scene space) and add it to the position
+        pos = $framebuffer_to_scene_or_visual(fb_pos);
+        x = $framebuffer_to_scene_or_visual(fb_pos + vec4(big_float, 0, 0, 0));
+        x = (x - pos);
+        // multiply that direction by the size and add it to the position
         // this gives us the position of the edge of the point, which we convert in screen space
-        size_vec = $scene_to_framebuffer(scene_pos + normalize(x) * a_size);
+        size_vec = $scene_or_visual_to_framebuffer(pos + normalize(x) * a_size);
         // divide by `w` for perspective, and subtract pos
         // this gives us the actual screen-space size of the point
         $v_size = size_vec.x / size_vec.w - fb_pos.x / fb_pos.w;
@@ -83,12 +73,13 @@ void main (void) {
     gl_PointSize = $v_size + 4. * (v_edgewidth + 1.5 * u_antialias);
 
     if (u_spherical == true) {
+        // similar as above for scaling, but in towards the screen direction
         // Get the framebuffer z direction relative to this sphere in visual coords
-        vec4 z = $framebuffer_to_visual(fb_pos + vec4(0, 0, big_float, 0));
+        vec4 z = $framebuffer_to_scene_or_visual(fb_pos + vec4(0, 0, big_float, 0));
         z = (z - pos);
         // Get the depth of the sphere in its middle point on the screen
         // size/2 because we need the radius, not the diameter
-        vec4 depth_z_vec = $visual_to_framebuffer(pos + normalize(z) * a_size / 2);
+        vec4 depth_z_vec = $scene_or_visual_to_framebuffer(pos + normalize(z) * a_size / 2);
         v_depth_middle = depth_z_vec.z / depth_z_vec.w - fb_pos.z / fb_pos.w;
         // size ratio between aliased and non-aliased, needed for correct depth
         v_alias_ratio = gl_PointSize / $v_size;
@@ -560,6 +551,7 @@ class MarkersVisual(Visual):
                  light_color='white', light_position=(1, -1, 1), light_ambient=0.3, **kwargs):
         self._vbo = VertexBuffer()
         self._data = None
+        self._scaling = "fixed"
 
         Visual.__init__(self, vcode=self._shaders['vertex'], fcode=self._shaders['fragment'])
         self._symbol_func = Function(self._symbol_shader)
@@ -573,11 +565,11 @@ class MarkersVisual(Visual):
                           blend_func=('src_alpha', 'one_minus_src_alpha'))
         self._draw_mode = 'points'
 
+        self.events.add(data_updated=Event)
+
         if len(kwargs) > 0:
             self.set_data(**kwargs)
 
-        self._scaling = "fixed"
-        self._scaling_int = 0
         self.scaling = scaling
         self.antialias = antialias
         self.light_color = light_color
@@ -662,6 +654,7 @@ class MarkersVisual(Visual):
             self._vbo.set_data(data)
             self.shared_program.bind(self._vbo)
 
+        self.events.data_updated()
         self.update()
 
     @property
@@ -702,19 +695,17 @@ class MarkersVisual(Visual):
     @scaling.setter
     def scaling(self, value):
         scaling_modes = {
-            False: 0,
-            True: 1,
-            "fixed": 0,
-            "scene": 1,
-            "visual": 2,
+            False: "fixed",
+            True: "scene",
+            "fixed": "fixed",
+            "scene": "scene",
+            "visual": "visual",
         }
         if value not in scaling_modes:
             possible_options = ", ".join(repr(opt) for opt in scaling_modes)
             raise ValueError(f"Unknown scaling option {value!r}, expected one of: {possible_options}")
-        scaling_int = scaling_modes[value]
-        self.shared_program['u_scaling'] = scaling_int
-        self._scaling = value
-        self._scaling_int = scaling_int
+        self._scaling = scaling_modes[value]
+        self.shared_program['u_scaling'] = self._scaling != "fixed"
         self.update()
 
     @property
@@ -799,16 +790,15 @@ class MarkersVisual(Visual):
 
     def _prepare_transforms(self, view):
         view.view_program.vert['visual_to_framebuffer'] = view.get_transform('visual', 'framebuffer')
-        view.view_program.vert['framebuffer_to_visual'] = view.get_transform('framebuffer', 'visual')
         view.view_program.vert['framebuffer_to_render'] = view.get_transform('framebuffer', 'render')
-        view.view_program.vert['framebuffer_to_scene'] = view.get_transform('framebuffer', 'scene')
-        view.view_program.vert['scene_to_framebuffer'] = view.get_transform('scene', 'framebuffer')
+        scaling = view._scaling if view._scaling != "fixed" else "scene"
+        view.view_program.vert['framebuffer_to_scene_or_visual'] = view.get_transform('framebuffer', scaling)
+        view.view_program.vert['scene_or_visual_to_framebuffer'] = view.get_transform(scaling, 'framebuffer')
 
     def _prepare_draw(self, view):
         if self._data is None:
             return False
         view.view_program['u_px_scale'] = view.transforms.pixel_scale
-        view.view_program['u_scaling'] = self._scaling_int
 
     def _compute_bounds(self, axis, view):
         pos = self._data['a_position']

vispy/visuals/text/_sdf_cpu.pyx

@@ -1,5 +1,4 @@
-# -*- coding: utf-8 -*-
-
+# cython: language_level=3, boundscheck=False, cdivision=True, wraparound=False, initializedcheck=False, nonecheck=False
 # A Cython implementation of the "eight-points signed sequential Euclidean
 # distance transform algorithm" (8SSEDT)
 
@@ -18,13 +17,14 @@ ctypedef np.complex64_t DTYPE_ct
 cdef DTYPE_ct MAX_VAL = (1e6 + 1e6j)
 
 
-@cython.boundscheck(False)  # designed to stay within bounds
-@cython.wraparound(False)  # we don't use negative indexing
 def _calc_distance_field(np.ndarray[DTYPE_t, ndim=2] pixels,
                          int w, int h, DTYPE_t sp_f):
     # initialize grids
-    cdef np.ndarray[DTYPE_ct, ndim=2] g0 = np.zeros((h, w), dtype_c)
-    cdef np.ndarray[DTYPE_ct, ndim=2] g1 = np.zeros((h, w), dtype_c)
+    cdef np.ndarray[DTYPE_ct, ndim=2] g0_arr = np.zeros((h, w), dtype_c)
+    cdef np.ndarray[DTYPE_ct, ndim=2] g1_arr = np.zeros((h, w), dtype_c)
+    cdef DTYPE_ct[:, ::1] g0 = g0_arr
+    cdef DTYPE_ct[:, ::1] g1 = g1_arr
+    cdef DTYPE_t[:, :] pixels_view = pixels
     cdef Py_ssize_t y, x
     for y in range(h):
         g0[y, 0] = MAX_VAL
@@ -32,9 +32,9 @@ def _calc_distance_field(np.ndarray[DTYPE_t, ndim=2] pixels,
         g1[y, 0] = MAX_VAL
         g1[y, w-1] = MAX_VAL
         for x in range(1, w-1):
-            if pixels[y, x] > 0:
+            if pixels_view[y, x] > 0:
                 g0[y, x] = MAX_VAL
-            if pixels[y, x] < 1:
+            if pixels_view[y, x] < 1:
                 g1[y, x] = MAX_VAL
     for x in range(w):
         g0[0, x] = MAX_VAL
@@ -50,37 +50,35 @@ def _calc_distance_field(np.ndarray[DTYPE_t, ndim=2] pixels,
     cdef DTYPE_t r_sp_f_2 = 1. / (sp_f * 2.)
     for y in range(1, h-1):
         for x in range(1, w-1):
-            pixels[y, x] = sqrt(dist(g0[y, x])) - sqrt(dist(g1[y, x]))
-            if pixels[y, x] < 0:
-                pixels[y, x] = (pixels[y, x] + sp_f) * r_sp_f_2
+            pixels_view[y, x] = sqrt(dist(g0[y, x])) - sqrt(dist(g1[y, x]))
+            if pixels_view[y, x] < 0:
+                pixels_view[y, x] = (pixels_view[y, x] + sp_f) * r_sp_f_2
             else:
-                pixels[y, x] = 0.5 + pixels[y, x] * r_sp_f_2
-            pixels[y, x] = max(min(pixels[y, x], 1), 0)
+                pixels_view[y, x] = 0.5 + pixels_view[y, x] * r_sp_f_2
+            pixels_view[y, x] = max(min(pixels_view[y, x], 1), 0)
 
 
-@cython.boundscheck(False)  # designed to stay within bounds
-@cython.wraparound(False)  # we don't use negative indexing
-cdef Py_ssize_t compare(DTYPE_ct *cell, DTYPE_ct xy, DTYPE_t *current):
+cdef inline Py_ssize_t compare(DTYPE_ct *cell, DTYPE_ct xy, DTYPE_t *current) noexcept nogil:
     cdef DTYPE_t val = dist(xy)
     if val < current[0]:
         cell[0] = xy
         current[0] = val
 
 
-@cython.boundscheck(False)  # designed to stay within bounds
-@cython.wraparound(False)  # we don't use negative indexing
-cdef DTYPE_t dist(DTYPE_ct val):
+cdef DTYPE_t dist(DTYPE_ct val) noexcept nogil:
     return val.real*val.real + val.imag*val.imag
 
 
-@cython.boundscheck(False)  # designed to stay within bounds
-@cython.wraparound(False)  # we don't use negative indexing
-cdef void _propagate(np.ndarray[DTYPE_ct, ndim=2] grid):
+cdef void _propagate(DTYPE_ct[:, :] grid) noexcept nogil:
     cdef Py_ssize_t height = grid.shape[0]
     cdef Py_ssize_t width = grid.shape[1]
     cdef Py_ssize_t y, x
     cdef DTYPE_t current
-    cdef DTYPE_ct a0=-1, a1=-1j, a2=-1-1j, a3=1-1j
+    cdef DTYPE_ct a0, a1, a2, a3
+    a0 = -1
+    a1 = -1j
+    a2 = -1 - 1j
+    a3 = 1 - 1j
     cdef DTYPE_ct b0=1
     cdef DTYPE_ct c0=1, c1=1j, c2=-1+1j, c3=1+1j
     cdef DTYPE_ct d0=-1

vispy/visuals/visual.py

@@ -83,9 +83,10 @@ A compound visual will automatically handle forwarding transform system changes
 and filter attachments to its internally-wrapped visuals. To the user, this
 will appear to behave as a single visual.
 """
-
 from __future__ import division
 import weakref
+from contextlib import contextmanager
+
 import numpy as np
 
 from .. import gloo
@@ -337,6 +338,7 @@ class Visual(BaseVisual):
                     raise ValueError("Cannot specify both program and "
                                      "vcode/fcode arguments.")
 
+        self._prev_gl_state = []
         self._program = self._vshare.program.add_program()
         self._prepare_transforms(self)
         self._filters = []
@@ -347,6 +349,11 @@ class Visual(BaseVisual):
 
         The arguments are forwarded to :func:`vispy.gloo.wrappers.set_state`.
 
+        This can also be used as a context manager that will revert the
+        gl_state on exit. When used as a context manager, this function is
+        designed to be constructed directly in the header of the `with`
+        statement to avoid confusion about what state will be restored on exit.
+
         Parameters
         ----------
         preset : str
@@ -354,14 +361,21 @@ class Visual(BaseVisual):
         **kwargs : dict
             Keyword arguments.
         """
+        prev_gl_state = self._vshare.gl_state.copy()
+
         self._vshare.gl_state = kwargs
         self._vshare.gl_state['preset'] = preset
 
+        return _revert_gl_state([(self, prev_gl_state)])
+
     def update_gl_state(self, *args, **kwargs):
         """Modify the set of GL state parameters to use when drawing.
 
         The arguments are forwarded to :func:`vispy.gloo.wrappers.set_state`.
 
+        This can also be used as a context manager that will revert the
+        gl_state on exit.
+
         Parameters
         ----------
         *args : tuple
@@ -369,12 +383,61 @@ class Visual(BaseVisual):
         **kwargs : dict
             Keyword arguments.
         """
+        prev_gl_state = self._vshare.gl_state.copy()
+
         if len(args) == 1:
             self._vshare.gl_state['preset'] = args[0]
         elif len(args) != 0:
             raise TypeError("Only one positional argument allowed.")
         self._vshare.gl_state.update(kwargs)
 
+        return _revert_gl_state([(self, prev_gl_state)])
+
+    def push_gl_state(self, *args, **kwargs):
+        """Define the set of GL state parameters to use when drawing.
+
+        The arguments are forwarded to :func:`vispy.gloo.wrappers.set_state`.
+
+        This differs from :py:meth:`.set_gl_state` in that it stashes the
+        current state. See :py:meth:`.pop_gl_state` for restoring the state.
+
+        Parameters
+        ----------
+        *args : tuple
+            Arguments.
+        **kwargs : dict
+            Keyword arguments.
+        """
+        self._prev_gl_state.append(self._vshare.gl_state.copy())
+        self.set_gl_state(*args, **kwargs)
+
+    def push_gl_state_update(self, *args, **kwargs):
+        """Modify the set of GL state parameters to use when drawing.
+
+        The arguments are forwarded to :func:`vispy.gloo.wrappers.set_state`.
+
+        This differs from :py:meth:`.update_gl_state` in that it stashes the
+        current state. See :py:meth:`.pop_gl_state` for restoring the state.
+
+        Parameters
+        ----------
+        *args : tuple
+            Arguments.
+        **kwargs : dict
+            Keyword arguments.
+        """
+        self._prev_gl_state.append(self._vshare.gl_state.copy())
+        self.update_gl_state(*args, **kwargs)
+
+    def pop_gl_state(self):
+        """Restore a previous set of GL state parameters if available.
+
+        If no previous GL state is available (see :py:meth:`.push_gl_state`),
+        this has no effect.
+        """
+        if self._prev_gl_state:
+            self.set_gl_state(**self._prev_gl_state.pop())
+
     def _compute_bounds(self, axis, view):
         """Return the (min, max) bounding values of this visual along *axis*
         in the local coordinate system.
@@ -616,6 +679,9 @@ class CompoundVisual(BaseVisual):
 
         The arguments are forwarded to :func:`vispy.gloo.wrappers.set_state`.
 
+        This can also be used as a context manager that will revert the
+        gl_state on exit.
+
         Parameters
         ----------
         preset : str
@@ -623,14 +689,21 @@ class CompoundVisual(BaseVisual):
         **kwargs : dict
             Keyword arguments.
         """
+        prev_gl_state = []
         for v in self._subvisuals:
+            prev_gl_state.append((v, v._vshare.gl_state))
             v.set_gl_state(preset=preset, **kwargs)
 
+        return _revert_gl_state(prev_gl_state)
+
     def update_gl_state(self, *args, **kwargs):
         """Modify the set of GL state parameters to use when drawing.
 
         The arguments are forwarded to :func:`vispy.gloo.wrappers.set_state`.
 
+        This can also be used as a context manager that will revert the
+        gl_state on exit.
+
         Parameters
         ----------
         *args : tuple
@@ -638,9 +711,58 @@ class CompoundVisual(BaseVisual):
         **kwargs : dict
             Keyword arguments.
         """
+        prev_gl_state = []
         for v in self._subvisuals:
+            prev_gl_state.append((v, v._vshare.gl_state))
             v.update_gl_state(*args, **kwargs)
 
+        return _revert_gl_state(prev_gl_state)
+
+    def push_gl_state(self, *args, **kwargs):
+        """Define the set of GL state parameters to use when drawing.
+
+        The arguments are forwarded to :func:`vispy.gloo.wrappers.set_state`.
+
+        This differs from :py:meth:`.set_gl_state` in that it stashes the
+        current state. See :py:meth:`.pop_gl_state` for restoring the state.
+
+        Parameters
+        ----------
+        *args : tuple
+            Arguments.
+        **kwargs : dict
+            Keyword arguments.
+        """
+        for v in self._subvisuals:
+            v.push_gl_state(*args, **kwargs)
+
+    def push_gl_state_update(self, *args, **kwargs):
+        """Modify the set of GL state parameters to use when drawing.
+
+        The arguments are forwarded to :func:`vispy.gloo.wrappers.set_state`.
+
+        This differs from :py:meth:`.update_gl_state` in that it stashes the
+        current state. See :py:meth:`.pop_gl_state` for restoring the state.
+
+        Parameters
+        ----------
+        *args : tuple
+            Arguments.
+        **kwargs : dict
+            Keyword arguments.
+        """
+        for v in self._subvisuals:
+            v.push_gl_state_update(*args, **kwargs)
+
+    def pop_gl_state(self):
+        """Restore a previous set of GL state parameters if available.
+
+        If no previous GL state is available (see :py:meth:`.push_gl_state`),
+        this has no effect.
+        """
+        for v in self._subvisuals:
+            v.pop_gl_state()
+
     def attach(self, filt, view=None):
         """Attach a Filter to this visual
 
@@ -681,6 +803,25 @@ class CompoundVisual(BaseVisual):
         return bounds
 
 
+@contextmanager
+def _revert_gl_state(prev_gl_state):
+    """Context manager to store and revert GL state for a list of visuals.
+
+    Parameters
+    ----------
+    prev_gl_state : list
+        A list of (Visual, gl_state) tuples, where gl_state is a dictionary of
+        `gl_state` params as would be passed to :py:func:`set_gl_state`.
+    """
+    for v, state in prev_gl_state:
+        v._prev_gl_state.append(state)
+    try:
+        yield
+    finally:
+        for v, _ in prev_gl_state:
+            v.pop_gl_state()
+
+
 class CompoundVisualView(BaseVisualView, CompoundVisual):
     def __init__(self, visual):
         BaseVisualView.__init__(self, visual)

{vispy-0.13.0.dist-info → vispy-0.14.0.dist-info}/METADATA

@@ -1,12 +1,12 @@
 Metadata-Version: 2.1
 Name: vispy
-Version: 0.13.0
+Version: 0.14.0
 Summary: Interactive visualization in Python
 Home-page: http://vispy.org
 Download-URL: https://pypi.python.org/pypi/vispy
 Author: Vispy contributors
 Author-email: vispy@googlegroups.com
-License: (new) BSD
+License: BSD-3-Clause
 Keywords: visualization,OpenGl,ES,medical,imaging,3D,plotting,numpy,bigdata,ipython,jupyter,widgets
 Platform: any
 Classifier: Development Status :: 3 - Alpha
@@ -19,12 +19,13 @@ Classifier: Operating System :: MacOS :: MacOS X
 Classifier: Operating System :: Microsoft :: Windows
 Classifier: Operating System :: POSIX
 Classifier: Programming Language :: Python
-Classifier: Programming Language :: Python :: 3.6
-Classifier: Programming Language :: Python :: 3.7
 Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
 Classifier: Framework :: IPython
 Provides: vispy
-Requires-Python: >=3.6
+Requires-Python: >=3.8
 Description-Content-Type: text/x-rst
 License-File: LICENSE.txt
 Requires-Dist: numpy
@@ -47,7 +48,7 @@ Requires-Dist: Pillow ; extra == 'io'
 Provides-Extra: ipython-static
 Requires-Dist: ipython ; extra == 'ipython-static'
 Provides-Extra: pyglet
-Requires-Dist: pyglet (>=1.2) ; extra == 'pyglet'
+Requires-Dist: pyglet >=1.2 ; extra == 'pyglet'
 Provides-Extra: pyqt5
 Requires-Dist: pyqt5 ; extra == 'pyqt5'
 Provides-Extra: pyqt6

{vispy-0.13.0.dist-info → vispy-0.14.0.dist-info}/RECORD

@@ -1,6 +1,6 @@
 vispy/__init__.py,sha256=Q-ECX_hCYaK0N0nHaVUQM6bNTUf4A3uGTxGcnlY2FFU,935
 vispy/conftest.py,sha256=SUNIUsn7o-cQa0mDMAhxoyeU_ENZjqO5B_xTJSNi-yQ,501
-vispy/version.py,sha256=BkTmmM-QQGNkrCcmNf5iJmL2noXSWEXW-ec3PugRN0A,166
+vispy/version.py,sha256=H75fMnWLjwm1ZPikWyWUVlZmuwO_sGw7HXy4afzlQQs,166
 vispy/app/__init__.py,sha256=NDhvVlPpRUm5zkfs4L1VwbdE1Hhg7dGEkI28RYH2KTM,640
 vispy/app/_default_app.py,sha256=ACldZQfK7nl2zGInuJBsCm1sfFKZE-UFBgSeavG8gVo,2497
 vispy/app/_detect_eventloop.py,sha256=h7IMsSZXuIAz9M3bezB_gB2BQqcfiPcdpo5vAn8cd7Y,6622
@@ -11,7 +11,7 @@ vispy/app/qt.py,sha256=7yos1jeDws_SqUddLzOfH4kKtaUkYqCuNA7gS-dBiB8,3503
 vispy/app/timer.py,sha256=8wzJCnXsrcOOboq0ngQz2LVCy8fV035UmQMlFseorrY,5928
 vispy/app/backends/__init__.py,sha256=vWTYrTxmF7ccEp3ovoREK--UuBMnXB9S6Ev-kmB0gcI,1889
 vispy/app/backends/_egl.py,sha256=NbuplBeyUeGnHjpQDrsaijY9d3JadW8UDryNIkfvOhc,8742
-vispy/app/backends/_glfw.py,sha256=1-WzSOBse-jNX3PqyYdIcRAiawbKwVd3gk-_hML8Pjg,17531
+vispy/app/backends/_glfw.py,sha256=HQwz4cmg9YQar3m01IN-96S1GoQ6k_YmT-qzcH0Ahj4,17534
 vispy/app/backends/_jupyter_rfb.py,sha256=V3f7sJ-LLhnYckUUNaNALLDQoek9L2EEs39e4brF_gM,9083
 vispy/app/backends/_offscreen_util.py,sha256=YHcJrKXAZPuPyYvu5yvh-XXUx7G8tncjGEhedUY9Q04,3818
 vispy/app/backends/_osmesa.py,sha256=XT0ueItVyAouAoSsUO4VAoq4AXyTmiUVVm9Kng5hbsE,7837
@@ -43,7 +43,7 @@ vispy/color/__init__.py,sha256=3IPPPTuiFWGfVmhFBSk5QCcNp-8_paj8HPrLmgkSFPY,661
 vispy/color/_color_dict.py,sha256=TqlZoWaeO3ddWwm57MaGqqoiDU5q0OmBBxpzhAcz-iM,5417
 vispy/color/color_array.py,sha256=KCOVxr_qvNfgZQI6lJHeyIVne3MeYAEx6t0V3DhFjAY,14860
 vispy/color/color_space.py,sha256=h0ntDbT4PTYaCYf2bEGRbVKI_HjbyQ2zuFSwAet9EQA,6232
-vispy/color/colormap.py,sha256=TeU3JF781JOS4O0KA0S74v_DeV7xgL_dW58FL1-7x0c,44788
+vispy/color/colormap.py,sha256=tsSL64QFavSyY_wzlYW2_5pXThvDC9oY02jYta5g6Jo,43720
 vispy/color/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vispy/color/tests/test_color.py,sha256=wghhl5hWzLQAJexx53X2pGqxKkzvq7EsZZB6fjP1JcQ,13271
 vispy/ext/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -80,7 +80,7 @@ vispy/gloo/glir.py,sha256=JPoIchay0FsZseejmRUProQi5gExDSkAxIIIUL3sc4A,67857
 vispy/gloo/globject.py,sha256=eMkpFZrqJYSHx8A5j1lH-uczqZk-IX2ZYb77E-b1DOM,4013
 vispy/gloo/preprocessor.py,sha256=lMp2OxCyZDb5gyLUYK3qLMhStrmbyIgnVYnmniWr-wE,2358
 vispy/gloo/program.py,sha256=Uvo4TN6EViPqaDHhbDmOQjKYm-K6c_WHnFgPEvqTscc,22867
-vispy/gloo/texture.py,sha256=9DJLtLoWdI0R-WP9OlIqs94j2UiLnDSIL8LERhGXrzc,39301
+vispy/gloo/texture.py,sha256=ULvBx-iBNo7z7yWZuhweL1yW-uPsuRTObC8URR03_GU,39467
 vispy/gloo/util.py,sha256=sC1OM-L0iY3ymJIU4eNOk_9hzDKZVNiKKHOBT_6m500,4548
 vispy/gloo/wrappers.py,sha256=Buyf8Xl8oPREzH9cn9Ez6ltQ6eaSKDfRrVmuA3GHys0,27222
 vispy/gloo/gl/__init__.py,sha256=U4QjPJQQNkGFPW2IrDE-KenH4xgcz5D3ULc-Mro39wM,8186
@@ -269,11 +269,11 @@ vispy/plot/plotwidget.py,sha256=7zRjuSYGc3J6rpUmfMbI10j0kS0qEo0rzuN-3N1RaIw,1911
 vispy/plot/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vispy/plot/tests/test_plot.py,sha256=KZYPQRC9dyr6mJebDSmEtW_mzT5gdLuhZGHpv1B9j3Y,1760
 vispy/scene/__init__.py,sha256=x8xRdezKIt0HKvqjEbMGkcpZ5ZGsF_athtHG0d7aOrQ,1530
-vispy/scene/canvas.py,sha256=WN3mNy_PL9XbfyqlxN9FUcWiStN9mGN0XiphR6Kk3IE,23479
+vispy/scene/canvas.py,sha256=5T522ppfQATjwEk7pgDXpKe72Ik6kB2wYR_gQwnFkYE,23407
 vispy/scene/events.py,sha256=0FUjs0IG9b-EuuYlDWOi-sHuuxVJWdHn13TDYPHv2K8,2548
-vispy/scene/node.py,sha256=GrJ88mhdJzZpnueYuHS0Vxo_z82mwpQWW_d4ZLwJcoM,19706
+vispy/scene/node.py,sha256=U0o5OzlAqyx9o-RnDLoQijINflnBxYyZdmev44UAEMw,20312
 vispy/scene/subscene.py,sha256=uIPaLqVpHxeK0YycOWxrdcNSrY4t3KkYqj6BckCS8O0,584
-vispy/scene/visuals.py,sha256=hov3DHpoCRNskV9mNN3Czdfr6pogR6oBqMS7DwJpGfo,10140
+vispy/scene/visuals.py,sha256=-sZfp5xdmB0tS8v8ZEJGaP6KY1FIR4ae8l--znzlM9M,10212
 vispy/scene/cameras/__init__.py,sha256=Yebnynea-WoUzrg72S6s9RVh2OkXY3FlYOxI6_EV2bk,1271
 vispy/scene/cameras/_base.py,sha256=CKRsQo7BtUTkQnKcSgL2qbIS5FtsGzO6ZNFWARrh4AY,1315
 vispy/scene/cameras/arcball.py,sha256=CfwtKfw5_q9XWj63NF8CuaDl4MVWZBU4iaMl3De3_kg,3712
@@ -290,7 +290,7 @@ vispy/scene/cameras/tests/test_perspective.py,sha256=AzXoWVd0c87Rxk1l7YJNP9yOF2p
 vispy/scene/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vispy/scene/tests/test_canvas.py,sha256=qspBRbyhERHR5H4AjxeaoGHGZ2uH0KVwG71Vj-3Db_o,4277
 vispy/scene/tests/test_node.py,sha256=drLZcMQNrS8ehsm5nVJ_yGV4HAJxOzZ-P89-4siETwM,5078
-vispy/scene/tests/test_visuals.py,sha256=Fspb4EbDkLKeUWk0Pqx3zFeM7IphHP5kYPyxgiN2_sA,1047
+vispy/scene/tests/test_visuals.py,sha256=t2Bghv2nfeftnpdU1NqDNhvx5tpCbQRvedVZRp1CZU0,4506
 vispy/scene/widgets/__init__.py,sha256=_6bqjoYW_5xSZGVjtpr3r6z2T1LaDOTZIYi-OWe15ns,701
 vispy/scene/widgets/anchor.py,sha256=EHuMUcdR7HZYNlfgMwuRzP8bD65EXElF8AVXxptsi7o,899
 vispy/scene/widgets/axis.py,sha256=rv2Egm1Fukybm08m--GDqxsIlk9-qkUHPSWtAJSM3Do,3042
@@ -394,7 +394,7 @@ vispy/visuals/isoline.py,sha256=Q6y524xuFUaHXTXXhVx52BPEeVaYsW0Re0ZTjlNe1IA,8749
 vispy/visuals/isosurface.py,sha256=BxcQRw9n0pdynvinB_WqpFCJzeVHC8RnGe4CJbgkiUw,4013
 vispy/visuals/line_plot.py,sha256=W9wZTANfV0_0EDbaCh4rCDM5xOn9VGiLGqU6juev-kU,5017
 vispy/visuals/linear_region.py,sha256=5CRd43NkV_hv2rUDQgumHyT7vgpWhbK5wRR5amagTk0,6813
-vispy/visuals/markers.py,sha256=lRjyxkLW9c0isBy0df3RvSBHmV8TqF-8KASG2SWWbq4,28243
+vispy/visuals/markers.py,sha256=MUUcVClc6oVoS_xY4JZWezZy30qH0kCnlZWGo8c95ww,27708
 vispy/visuals/mesh.py,sha256=nW_HYW7vXK_02jAv-UxWHfGquMi2SY1rkB-OUcWx74g,12340
 vispy/visuals/mesh_normals.py,sha256=mLZd7Ops19M2RqCzRTHa3o61zhvwu2umE7ud4gqvkaw,6513
 vispy/visuals/plane.py,sha256=U_FI8y5BejtjTnroGeKYkOTOdQPSUL1IlO1ZVXdfb-I,2257
@@ -406,7 +406,7 @@ vispy/visuals/spectrogram.py,sha256=Dho8_mOxvxT8QzdUIbUqOGNdSJhtf4IeZjyVNp1ZtZM,
 vispy/visuals/sphere.py,sha256=2JMsmoyjQvO6F7G-W1Bg2wAUQjyyeoTPWCPTQs04B1U,3171
 vispy/visuals/surface_plot.py,sha256=0Po1no74ln5lE5ddtSkCyjiBkkraWldv_04lpskgZUY,7471
 vispy/visuals/tube.py,sha256=Attnn3Dtue0hTmONb3dDT0A56TAAkHoVumSMm26TyN8,6158
-vispy/visuals/visual.py,sha256=tt8A4tdkcxtZTPrWMAVd204qq_IAGpdpOaK9XWcoKvk,25900
+vispy/visuals/visual.py,sha256=WnQQGr46ACEwiPnVDv_J0e3qEOSEkvZEdDwYEZpPvGM,30714
 vispy/visuals/volume.py,sha256=wZJYZGmX0_Qg24C5_mbWes7u7OiMpoM4R0IhdJfL81c,50464
 vispy/visuals/windbarb.py,sha256=8mgIMTlzsp20EnY8_ZjX_jUAyciu1ErXY-Ta2Ec2FJo,9597
 vispy/visuals/xyz_axis.py,sha256=13Ni3QO8NYQsB5UzQXTZY7mF_TgQskzOZTPLKsHZIDw,991
@@ -429,14 +429,16 @@ vispy/visuals/collections/raw_triangle_collection.py,sha256=LmxecFmMVN4Pb8QQM2To
 vispy/visuals/collections/segment_collection.py,sha256=9Feu1zFgTmnsnsMIHSJeCY8mEz864nD9dBki_GlToxs,816
 vispy/visuals/collections/triangle_collection.py,sha256=hnEVDh8fmduTedtdwqAv6B1zMLQMAkRNCAY5KBAj5hM,641
 vispy/visuals/collections/util.py,sha256=a1VIXCcLQo-sgROJaRmSe7JacnVoIrkFD_qAWg_Jkzc,5391
-vispy/visuals/filters/__init__.py,sha256=xqbceJPl3vA9JVoRxjn3rkJSb0JQ0WuVXp4hJehWjxs,463
-vispy/visuals/filters/base_filter.py,sha256=pzQpIDBB60c9hk5AfQxl0cP-vJaB_F1PPWjKDX4CGfY,3599
+vispy/visuals/filters/__init__.py,sha256=BmbLl8w9ZOEdRU8fhycHQn7TH5U-YvJGStd-HUuk7SU,556
+vispy/visuals/filters/base_filter.py,sha256=wkH5QSzr9EchFH9GEMDNgz5J2wOD09KP0Cd_HX25cQY,7766
 vispy/visuals/filters/clipper.py,sha256=S4O8DE0W2Mrn070Ra8y9weFyYrfkj-rMTDnxKHCnXD4,1801
 vispy/visuals/filters/clipping_planes.py,sha256=xyZopj2zg6vK1IhxwGRK-PyxBlViFLyjAmH2x41BLc0,4649
 vispy/visuals/filters/color.py,sha256=M_aF-TNCtwDjfvpbtjH62ToVCNrfMKEDMB_kgxR36ks,5230
-vispy/visuals/filters/mesh.py,sha256=B7gk12YuX1TMdp--3cN6Ei-IGZ_N9nHkkqMhPH6NN-g,26064
+vispy/visuals/filters/markers.py,sha256=qS6EstAuH55oC6khhsXtw2_dXkZy1xgAlRTv3xRuIdA,799
+vispy/visuals/filters/mesh.py,sha256=S9U15viRCJUGSfYpRR3tVZ4wQBXIP4O5egJeRmDnRIw,26896
 vispy/visuals/filters/picking.py,sha256=449YDNZYR14jt6KMhzs41wz1lsik7F0p2YaMZnyFZHo,1597
 vispy/visuals/filters/tests/__init__.py,sha256=yhDex0XDn0SIeqRp8QezJPJ3uoF6XE4TjIIi5suyVU0,163
+vispy/visuals/filters/tests/test_primitive_picking_filters.py,sha256=KpDuc4Sn_hMV9j4BIsYH--fcTtPIrPOYJiQWMi3nE6I,2212
 vispy/visuals/filters/tests/test_wireframe_filter.py,sha256=NpY32ZR7aQGIJj5NFVTD2OC2q-zOZd4e0SZFiwf7MmM,507
 vispy/visuals/glsl/__init__.py,sha256=XHRaWJLE8newB7J_DGGehXn62eY7lRH-7J5gqxuluTY,44
 vispy/visuals/glsl/antialiasing.py,sha256=aIP-KikzSCwqRobgiSGL_GnjfKmobizSsHGD-ed2Cqg,3328
@@ -454,7 +456,7 @@ vispy/visuals/graphs/tests/test_layouts.py,sha256=AfeOD0I3NG8cINMPiLy-oA_AXhTo7a
 vispy/visuals/graphs/tests/test_networkx_layout.py,sha256=2m9vh9FmkI4dhGS_Ly0yU0K6Vj7wbHEv_f5IZeAKsQM,1564
 vispy/visuals/line/__init__.py,sha256=KTtPT4TxidIEHJ2NI-qAzI8JReDgDVcivJ00rwTd-g0,242
 vispy/visuals/line/arrow.py,sha256=7Tx3u54Vo2MO8E8_UbYTj0XVHjRbfXvVH_90BGnGMUA,10439
-vispy/visuals/line/dash_atlas.py,sha256=G29DQoAbLlpoJUuxbe77I09rtUWkEYbrXmtp1rpJpk4,3037
+vispy/visuals/line/dash_atlas.py,sha256=FgQscJavb6mAV9t8ucyfwjS-F2LreBHcr4TJ1N0eG5A,3065
 vispy/visuals/line/line.py,sha256=QLlEJ2xMkY83TByK-BesK0rvYPf4ZgQ7Qp7NAwr5iaQ,19065
 vispy/visuals/shaders/__init__.py,sha256=j2euRzM-OfZYC3L5y88P8h5eBrBxYlNW9m8Qlylhpw0,691
 vispy/visuals/shaders/compiler.py,sha256=EG9Qv-zZLN7CfzUSw_mycSjxffxKo9vznGn0qGJZhGE,7506
@@ -496,8 +498,8 @@ vispy/visuals/tests/test_text.py,sha256=webfWtJcSgUkj3QBtZ4kggrs5OdkGZGb0byYc4mt
 vispy/visuals/tests/test_volume.py,sha256=mepaB3ssWl0s4gFU_yYTlhsQ1TCCkg_KtdTkLvR2Brs,18120
 vispy/visuals/tests/test_windbarb.py,sha256=cqEEcAnPMf29ZloL2fWJo2N04lrJgmQnD-Kt8mXWEQA,1135
 vispy/visuals/text/__init__.py,sha256=qWgGDKR-ezH4ZzzGKfs72S_zOauVDn5snJ5uHnYv6LE,364
-vispy/visuals/text/_sdf_cpu.cp311-win_amd64.pyd,sha256=97Jc33-ronScY5CGt6pQfvOV5mCVnDaRra_41rp0OXE,47104
-vispy/visuals/text/_sdf_cpu.pyx,sha256=QQjYt9D4LKP_DtwJ8g_rBA3ZToVh2atDZquL8lRsUV4,4035
+vispy/visuals/text/_sdf_cpu.cp311-win_amd64.pyd,sha256=q1qP_SqJ_nSJHqxUs7WJ8SXUAQDSKMU69UCGS98xH-s,154112
+vispy/visuals/text/_sdf_cpu.pyx,sha256=HiFaCXt0FgauyWD8WPpqESjp6mt9qx8n_s_CMRx8brc,3901
 vispy/visuals/text/_sdf_gpu.py,sha256=XW5nKivmvUx7tA8LebC7u7N37QQfBcMSUrdPvkG9JU8,10796
 vispy/visuals/text/text.py,sha256=hK8oSjF34PfczzBa5V7nmsR6uCfI-eqcR3zUB73YpjA,25928
 vispy/visuals/transforms/__init__.py,sha256=BNbVO0GWBoQZShivY_RDrRHcey-zOmQoF1A47hXgua4,1264
@@ -510,8 +512,8 @@ vispy/visuals/transforms/nonlinear.py,sha256=oiHDhqoM9E4rBGMmqZtVSJVspt1FgZORig6
 vispy/visuals/transforms/transform_system.py,sha256=dKRMid1Gm0bhh9K_v1RiC-xxbmQF61OHz_0Ur8GdMmU,14098
 vispy/visuals/transforms/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vispy/visuals/transforms/tests/test_transforms.py,sha256=QbAo0I3g5VkaQzzsZ03zktP-ge2JiXQeD2rqV6_LK7o,7114
-vispy-0.13.0.dist-info/LICENSE.txt,sha256=oENMqsC-O8FBKA0sbJxkd_T1-rK5oVsTFdfC4IzuRIs,1810
-vispy-0.13.0.dist-info/METADATA,sha256=ySWUtTEvlgnYED8UsIixFED01pgGuXW9ISmJwMgLnbI,8492
-vispy-0.13.0.dist-info/WHEEL,sha256=9wvhO-5NhjjD8YmmxAvXTPQXMDOZ50W5vklzeoqFtkM,102
-vispy-0.13.0.dist-info/top_level.txt,sha256=mciStn1SI48jYwEhJXlrMJ3HaJ90XOr5ZGJ8YdFI674,6
-vispy-0.13.0.dist-info/RECORD,,
+vispy-0.14.0.dist-info/LICENSE.txt,sha256=oENMqsC-O8FBKA0sbJxkd_T1-rK5oVsTFdfC4IzuRIs,1810
+vispy-0.14.0.dist-info/METADATA,sha256=hZn5MXgoX9LjjLNpR2_59X9BG5xG4ccm1gKKGzbdGM0,8546
+vispy-0.14.0.dist-info/WHEEL,sha256=badvNS-y9fEq0X-qzdZYvql_JFjI7Xfw-wR8FsjoK0I,102
+vispy-0.14.0.dist-info/top_level.txt,sha256=mciStn1SI48jYwEhJXlrMJ3HaJ90XOr5ZGJ8YdFI674,6
+vispy-0.14.0.dist-info/RECORD,,

{vispy-0.13.0.dist-info → vispy-0.14.0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: bdist_wheel (0.40.0)
+Generator: bdist_wheel (0.41.2)
 Root-Is-Purelib: false
 Tag: cp311-cp311-win_amd64