vispy 0.13.0__cp310-cp310-macosx_10_9_x86_64.whl → 0.14.0__cp310-cp310-macosx_10_9_x86_64.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,10 +1,5 @@
-vispy-0.13.0.dist-info/RECORD,,
-vispy-0.13.0.dist-info/WHEEL,sha256=doY7Ynwndq62v9G9yH4QQiKEI6qNEsMeVrkmo76vHLE,111
-vispy-0.13.0.dist-info/top_level.txt,sha256=mciStn1SI48jYwEhJXlrMJ3HaJ90XOr5ZGJ8YdFI674,6
-vispy-0.13.0.dist-info/LICENSE.txt,sha256=SyGjHD8uWIdCicPnNsCNMhwjJomQCArryMh7QGkD3JI,1774
-vispy-0.13.0.dist-info/METADATA,sha256=k8JNLtGKFWluu5LvtZi3DJSH1iUMlN5OTES3HL_IqrQ,8275
 vispy/conftest.py,sha256=1qkMPiB5SHGll3Sbvz9iBIAVeyaIuW7YDw8VpfKTMzk,489
-vispy/version.py,sha256=f-9LbbVLxrMv9t2MAPnCkiOGpkpxS3NyVpWFhOoKg6A,162
+vispy/version.py,sha256=uwy8vZw1JYKQhBZgHVBJvAgtZKgZS7cfmR39J3Flq0E,162
 vispy/__init__.py,sha256=Sm3hzOs_-fXTikZnwAFZoLOvETmFCw8BsSoAguXvhdY,902
 vispy/app/_detect_eventloop.py,sha256=hMht958_W6MVGEfJS7UMTRnIHyoODeJ6oVCaDXJZ5H8,6474
 vispy/app/timer.py,sha256=zIQwcF-XmowAHqe25z4nMwiRTMaNOnjz4IeTQClE8bg,5754
@@ -17,7 +12,7 @@ vispy/app/canvas.py,sha256=DXjjdCcIgoE8wYpbZBqOPXW_7eq3QR0OJTHSdayNLnk,28849
 vispy/app/backends/_pyside2.py,sha256=C8dxVEDRWKrzaH2QnlB98wM4gpFT048nzNEHZC0Gipk,1965
 vispy/app/backends/_jupyter_rfb.py,sha256=cN7sgJafp8L9Um36K89V1JS1EfUsn0AiUHBmWBMIUzk,8805
 vispy/app/backends/_pyside6.py,sha256=bihad8zmp1UsjGdeLyGnYlmHZivGe99H4h3A-UJG0jU,1816
-vispy/app/backends/_glfw.py,sha256=qQy8l1W5fRqO8rf63EFv1DNBaxF4gNNRdkTthewO7vg,17018
+vispy/app/backends/_glfw.py,sha256=xTXcH1oms8XoZeAOKJ19yRcR7N63BVjaqEQCtKy-nyc,17021
 vispy/app/backends/_pyglet.py,sha256=vx8GsKA30APkn9U2_UVghJfVo5uuskt_cPxehAgP7Dw,15110
 vispy/app/backends/_pyqt6.py,sha256=w3_ky9vIxTfviVMnm4kqv3m_xhleIqMYTgwXXENFSqo,1422
 vispy/app/backends/_qt.py,sha256=-Frs4Cmjwo-3pqIVV385gX6FDRNE3NcsUr23ECsB1B8,35449
@@ -123,7 +118,7 @@ vispy/gloo/context.py,sha256=cFlSfTlr-WQLWfksOqFXjqCel2F5kk9nR1RTdjLhyPM,8640
 vispy/gloo/wrappers.py,sha256=38_YO3Td70B_CNFKysff61jfAyMaaDu_lteIeotVu0c,26460
 vispy/gloo/framebuffer.py,sha256=77lIv9iojJ3tPm6ZsE8hRS0Iv9UdyoCRDC0RtxKTR-o,9350
 vispy/gloo/buffer.py,sha256=P7zC2JsVMr_ng6rOWJgL93iQWfPJqCJofaoEh8EZ0cg,16746
-vispy/gloo/texture.py,sha256=vPP3z1JjLxHsPV2YI76K-UOsoNzFSbsqjQbJE2Iy-1g,38258
+vispy/gloo/texture.py,sha256=u8dWlGa0zj0CAh84sfUhvd0DJNZHdBjObtUlNSmYN18,38422
 vispy/gloo/program.py,sha256=fsrl5kJ5aLX46M7cwPBl9QuZ4DP55Oa0I0QUprKUvok,22324
 vispy/gloo/tests/test_glir.py,sha256=e8hiifOuNehzDAqg4x5zqNKB-pzcPe-lP_RL4ZpLKoo,9644
 vispy/gloo/tests/test_buffer.py,sha256=RMbQeeKSG2lO2gxqmHx2CfMP841MbnbYDYNb6SxLc40,19819
@@ -152,7 +147,7 @@ vispy/gloo/gl/tests/test_basics.py,sha256=jTnERZwk3Qeg86__8N7oBfu3A02OHVfoT204cn
 vispy/gloo/gl/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vispy/gloo/gl/tests/test_use.py,sha256=C4S4BXTg2_2snJnwISvJecufesxVgC6zfqicTZINGb8,1838
 vispy/gloo/gl/tests/test_functionality.py,sha256=3OTTA_SHwiq-3fxNQKwQV8doAnr4Xe-BFmeqr93Xu3o,17340
-vispy/color/colormap.py,sha256=Nd0xApe-zYIAK9-4p-DunowQfgowSL1qVJhnsUnVQQ4,43634
+vispy/color/colormap.py,sha256=Xp7e05oaJausMOvl1UciqDagPuq61GJA9iJq4wpdMfw,42586
 vispy/color/__init__.py,sha256=aePQV4OX_2QsRcILIHdzlirVfGvfAxFgmaajLFqMjXo,644
 vispy/color/color_space.py,sha256=WcVdx-Bio8GSC9-VTcjpXBZ970uE3OZGgDF27MpBFX0,6051
 vispy/color/color_array.py,sha256=egFLGVDcXkTTGSHE12cXynRGSFJWXbr1g9dFWMXpGwQ,14413
@@ -347,9 +342,9 @@ vispy/visuals/infinite_line.py,sha256=A5D8zn_6M_4U0SCa2JacRIxmofBGgQMxa4gn8f3wgA
 vispy/visuals/gridmesh.py,sha256=It0s6Mj4A5kVuDVy6-xkUqC0Yq1mgoqH8JF9uN02zf8,3346
 vispy/visuals/surface_plot.py,sha256=hwKaTVJW0ty9zXp2HCI4NWr2irUYuasI7IknQwreG8U,7279
 vispy/visuals/cube.py,sha256=Cly3BjLLr436IUrQdRuL8FmSxXO0siKrxpCVaDxM-6U,1723
-vispy/visuals/markers.py,sha256=I_4zKZ0qYs6eov_rKxg2w54g3jo_YY5mq97bQxG_Ywg,27423
+vispy/visuals/markers.py,sha256=EsjarX9enN1CzfEN5JyGihX7sPbj_36eadvPglrF29I,26898
 vispy/visuals/rectangle.py,sha256=r7eKBo1HH0WAGTxeXFBfHJN0Zvjfue7JcDFTdcMiWmU,6664
-vispy/visuals/visual.py,sha256=yR7T5D0m_ZLxrGQy_XZKQzAz9901d4f0IU_nkTged-E,25118
+vispy/visuals/visual.py,sha256=Oo-skll6aDN1lkzMgrxeSPN4Xjf9OwRoOGD9YF_58vU,29791
 vispy/visuals/ellipse.py,sha256=jG_fryPB4mDEJtzeX8YhK7xf_Jz-oAjIqXNu87S8S2Y,5092
 vispy/visuals/line_plot.py,sha256=eqV9Trg8kU8t2C9dXfINAIsM7QK4BeAgWG2QMkqde-E,4882
 vispy/visuals/spectrogram.py,sha256=cf8PfG_hHZ3aUM8SExpIG5Tmr57N9gEF0-R6jPQ2K00,4940
@@ -365,12 +360,14 @@ vispy/visuals/isoline.py,sha256=O8-01BlZVu9mJXIH09eSzczyQYVAS4JSJuzCLQCPxdY,8508
 vispy/visuals/filters/color.py,sha256=un6uQb3Bnt4fIrwD0V2XrHbTW_RZebIIXh-YOs1XFHI,5049
 vispy/visuals/filters/clipper.py,sha256=W-00FBPR4jl38K7e5X-E_p-LqzTitJDQIskh74Zy-4o,1741
 vispy/visuals/filters/clipping_planes.py,sha256=yH1Pe11bE79nbNsm1wSP8pXFxjpM8KWjEPTyPeLW16o,4527
-vispy/visuals/filters/__init__.py,sha256=sqml9pNgdNw8z5Z27VwJa8lhgc3WPTqgQj3Uxh5mD6Y,454
-vispy/visuals/filters/mesh.py,sha256=wunI3gZrJAjW7M_C_eMJk2_k-wffjWNap6-vVJ3jrr8,25296
+vispy/visuals/filters/__init__.py,sha256=gdYW5_HESDnVumjKNiseMuDwffcsKwJRBqn_XEUVMUo,546
+vispy/visuals/filters/mesh.py,sha256=ynY1Wl-PE3_-IdZ5OpB3K-vK9HCXheYJBVnEOExki0s,26100
+vispy/visuals/filters/markers.py,sha256=A-cker7Q-byrQR-Mkqs6LkVNMKxcylza5Wf_axiFmaY,771
 vispy/visuals/filters/picking.py,sha256=tjlZPGwvocRbhxc0fo9baThE0XINMI3NyIPOzULqhGQ,1537
-vispy/visuals/filters/base_filter.py,sha256=IUByLoAvM-uGEzJ6YgPbGd2M8m0-s-AnCXqHzfk0CPM,3477
+vispy/visuals/filters/base_filter.py,sha256=1feDQZCJs0KJamGORi9LqYqZSz0tCAdKEgSpx9uu2Oo,7524
 vispy/visuals/filters/tests/__init__.py,sha256=n37y2k9PfraS0MCHjzGmZMQwq4JrV8drcY6_LBPegSk,160
 vispy/visuals/filters/tests/test_wireframe_filter.py,sha256=dOC_Mbu6vaO4k1Df_RrlfdYNemdXhbm1abIn-Pd5KCo,491
+vispy/visuals/filters/tests/test_primitive_picking_filters.py,sha256=psdK7V00cZHm2T-N5J8PtgUB0qUSCUAJ_f_jcMNJMSk,2142
 vispy/visuals/tests/test_rectangle.py,sha256=C4g0A3D5KxeYAkudF3h-xybobcapJAVf-etq1qMwe_k,6658
 vispy/visuals/tests/test_volume.py,sha256=VY3NBuGjc90d2EWAjbKv-rxPTRKdKZB4LQ8CSheck0I,17578
 vispy/visuals/tests/test_isosurface.py,sha256=D_z3tzVuOf8StocyDJ9YWu6Tcih1AsX48SqQbrzkIkg,469
@@ -410,7 +407,7 @@ vispy/visuals/transforms/_util.py,sha256=PV6m0Per-EP4yb-CnQwYucl7-d3xWYgJ5aRN5T2
 vispy/visuals/transforms/interactive.py,sha256=bIhovKNyYICNIl-WS5F2FlpUp3RXimklH4dWxbDVYOM,2770
 vispy/visuals/transforms/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vispy/visuals/transforms/tests/test_transforms.py,sha256=u8TbJ0ZJJBqGR78SCZTCC9HxyxShIlaaMK1EVFao2e4,6871
-vispy/visuals/line/dash_atlas.py,sha256=HLz-i7lnsXAGj6_hdeAkvVq78vBVKJ2gXUoZY30yWko,2952
+vispy/visuals/line/dash_atlas.py,sha256=91R7NkXdZX1Jv5WydFaM2XfFOLz2L6txO5ZwbMYqjpc,2975
 vispy/visuals/line/line.py,sha256=bBGEO0RhfXd9HWMy994BpppB2D5IExmpLCg13TmWJq8,18520
 vispy/visuals/line/arrow.py,sha256=jOezGwNIf-uBlOjE67pq6rPfej6VUbAjs_rWVzhwNM4,10150
 vispy/visuals/line/__init__.py,sha256=YHmBu9i0u9YIDEGJtFfgVu8F2QaeJOU0CrWq6rpmleg,236
@@ -438,8 +435,8 @@ vispy/visuals/graphs/layouts/force_directed.py,sha256=uEquUaboL_26QG3IeIhN20AzAS
 vispy/visuals/graphs/layouts/random.py,sha256=ox3JXQ1ysTGYHYYicIDBAZzNzzIKBbFln2yY1dNRtz8,1674
 vispy/visuals/graphs/layouts/circular.py,sha256=hEKjN2ow9mtQRZCslOpIkZWMTp5QM_HI9NuObNH0P7g,1559
 vispy/visuals/graphs/layouts/networkx_layout.py,sha256=pqF1JClCUYj-Cjf-tcphzo4Z3Ym_ha5Arxo68tYj-es,3583
-vispy/visuals/text/_sdf_cpu.cpython-310-darwin.so,sha256=acUqTt3yei_JGaBqjI906G4u0qOBcuwntULre4pIXvM,67304
-vispy/visuals/text/_sdf_cpu.pyx,sha256=NJTaZbyTvz_R2mjezuiQTppatfUUxZwLP3YnElr54E4,3923
+vispy/visuals/text/_sdf_cpu.cpython-310-darwin.so,sha256=nHlx02npOMax1TBktaqVH0Dl0wT22nwGznJhZvdJjZg,214344
+vispy/visuals/text/_sdf_cpu.pyx,sha256=_P7SWbsPwKpEg3d7L0P-Rgw3l-YoClF6dOrtsahxZUk,3791
 vispy/visuals/text/__init__.py,sha256=XyFi9zGWKpgWKC6xm0uMQZD1yzWU5TBi3jzoIehZ-dM,357
 vispy/visuals/text/text.py,sha256=nyenaB3kj0YI6EpO9PCMH9RHMa4l9G1OoygZbOwksaE,25253
 vispy/visuals/text/_sdf_gpu.py,sha256=uQwtOfH0tzZSlOP7uSY28SUK4_yk-dWwmmJRPXVAgD0,10480
@@ -483,13 +480,13 @@ vispy/geometry/tests/test_triangulation.py,sha256=eh8K-pi55xnHbvpQgnvrfHkr8H4HdF
 vispy/geometry/tests/test_generation.py,sha256=4geYGZvwaY4jEs1OzNhXsLaH7EdW6FjyGko6qvzs9Kc,2110
 vispy/scene/events.py,sha256=InGc7WIv4C9KSZ1pinIuvhJg0QEAY8i6U3QOiBoq29I,2463
 vispy/scene/__init__.py,sha256=-YeoqfxnXOCd7MI98ud-ZFU7B4YPxH_c5N5oG91CGhU,1487
-vispy/scene/node.py,sha256=kW90B2JPaOUeulLkLFIe4x3ihHG2DQLyIRfr1MVszsg,19078
-vispy/scene/visuals.py,sha256=0iSBxfXyTSqrSMv1j6CbvjuoFUpJacv-rXpKiStSfgI,9867
+vispy/scene/node.py,sha256=QhxUtCoUTI0-Aq4fhWUQPqT6nMAI3dLAvF-CdBLx8xY,19668
+vispy/scene/visuals.py,sha256=tSJeXvKyGt3WgYBmb5F_dP18jS5f1NJAbkMf4VbfpZg,9936
 vispy/scene/subscene.py,sha256=fNU9YHRL7yqiT3kTTBpzc5nFm5Vd-OAQa6dcQES40JE,564
-vispy/scene/canvas.py,sha256=QBQl3zbzMxrniPFq2FAEMWrPRBBLXX8iyZ_XTHVgO30,22837
+vispy/scene/canvas.py,sha256=xPr6jlneQ7jCEMgFlxq34NE1gIErsE4zx2YpjVoNzpc,22768
 vispy/scene/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vispy/scene/tests/test_canvas.py,sha256=dFcC9duJyOCg2JBaasUwgT-NEQjfAgb-XOcj_UWpt6E,4158
-vispy/scene/tests/test_visuals.py,sha256=XOuuIzi039LW3u6R758WKt-H1289NGW3Hti-_VjIIc8,1019
+vispy/scene/tests/test_visuals.py,sha256=9CEdLH8Z6LTio8IMvCMILs_Bt2-wvdumSv473eltR0E,4365
 vispy/scene/tests/test_node.py,sha256=6bz5LpcsVtEhT2Y-TwvU2n1QOR4gBdKofMa7qiyk21U,4936
 vispy/scene/cameras/_base.py,sha256=R0Z8xl2BTu652doO8zcVrWSJD_hjWo00DYN81qRWnIA,1277
 vispy/scene/cameras/magnify.py,sha256=O4Ba-UVo0tr31KCgm1LqPTn-ohikLkY2VYCOF3VzjLc,5387
@@ -515,3 +512,8 @@ vispy/scene/widgets/viewbox.py,sha256=gZekx8GSoJj8vRvqJ7Hw5Y5L1kVCmQQrF_f5YQOkkE
 vispy/scene/widgets/label.py,sha256=2ynsXsQNgIRFFkLzftVr1p94nLYLRlr_WWATDuJq7-8,1308
 vispy/scene/widgets/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vispy/scene/widgets/tests/test_colorbar.py,sha256=Yp1A_nZKC9NTSzdTM6OYKAcMEk0QH1CYUlhpMuxmQ3A,1362
+vispy-0.14.0.dist-info/RECORD,,
+vispy-0.14.0.dist-info/WHEEL,sha256=3ggQLyEtwymd0rFFn7Y7bZeC-TPY--XSbFQw5jO7PyA,111
+vispy-0.14.0.dist-info/top_level.txt,sha256=mciStn1SI48jYwEhJXlrMJ3HaJ90XOr5ZGJ8YdFI674,6
+vispy-0.14.0.dist-info/LICENSE.txt,sha256=SyGjHD8uWIdCicPnNsCNMhwjJomQCArryMh7QGkD3JI,1774
+vispy-0.14.0.dist-info/METADATA,sha256=FNXAytjqW3a0Nk_vCqgbqth3tH4H9tqTihynR7hEy4E,8328

{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: cp310-cp310-macosx_10_9_x86_64