vispy 0.12.0__cp310-cp310-win_amd64.whl → 0.14.0__cp310-cp310-win_amd64.whl

vispy/scene/canvas.py

@@ -140,6 +140,7 @@ class SceneCanvas(app.Canvas, Frozen):
         self.events.mouse_move.connect(self._process_mouse_event)
         self.events.mouse_release.connect(self._process_mouse_event)
         self.events.mouse_wheel.connect(self._process_mouse_event)
+        self.events.touch.connect(self._process_mouse_event)
 
         self.scene = SubScene()
         self.freeze()
@@ -344,7 +345,12 @@ class SceneCanvas(app.Canvas, Frozen):
 
     def _process_mouse_event(self, event):
         prof = Profiler()  # noqa
-        deliver_types = ['mouse_press', 'mouse_wheel']
+        deliver_types = [
+            'mouse_press',
+            'mouse_wheel',
+            'gesture_zoom',
+            'gesture_rotate',
+        ]
         if self._send_hover_events:
             deliver_types += ['mouse_move']
 
@@ -487,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_
@@ -524,6 +527,7 @@ class SceneCanvas(app.Canvas, Frozen):
         self.events.mouse_move.disconnect(self._process_mouse_event)
         self.events.mouse_release.disconnect(self._process_mouse_event)
         self.events.mouse_wheel.disconnect(self._process_mouse_event)
+        self.events.touch.disconnect(self._process_mouse_event)
 
     # -------------------------------------------------- transform handling ---
     def push_viewport(self, viewport):

vispy/scene/events.py

@@ -71,6 +71,15 @@ class SceneMouseEvent(Event):
         """The increment by which the mouse wheel has moved."""
         return self.mouse_event.delta
 
+    @property
+    def scale(self):
+        """The scale of a gesture_zoom event"""
+        try:
+            return self.mouse_event.scale
+        except AttributeError:
+            errmsg = f"SceneMouseEvent type '{self.type}' has no scale"
+            raise TypeError(errmsg)
+
     def copy(self):
         ev = self.__class__(self.mouse_event, self.visual)
         return ev

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, 
@@ -63,7 +64,8 @@ class Node(object):
         # Add some events to the emitter groups:
         events = ['canvas_change', 'parent_change', 'children_change', 
                   'transform_change', 'mouse_press', 'mouse_move',
-                  'mouse_release', 'mouse_wheel', 'key_press', 'key_release']
+                  'mouse_release', 'mouse_wheel', 'key_press', 'key_release',
+                  'gesture_zoom', 'gesture_rotate']
         # Create event emitter if needed (in subclasses that inherit from
         # Visual, we already have an emitter to share)
         if not hasattr(self, 'events'):
@@ -625,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
@@ -244,6 +247,7 @@ Histogram = create_visual_node(visuals.HistogramVisual)
 Image = create_visual_node(visuals.ImageVisual)
 ComplexImage = create_visual_node(visuals.ComplexImageVisual)
 InfiniteLine = create_visual_node(visuals.InfiniteLineVisual)
+InstancedMesh = create_visual_node(visuals.InstancedMeshVisual)
 Isocurve = create_visual_node(visuals.IsocurveVisual)
 Isoline = create_visual_node(visuals.IsolineVisual)
 Isosurface = create_visual_node(visuals.IsosurfaceVisual)

vispy/util/gallery_scraper.py

@@ -89,6 +89,7 @@ class VisPyGalleryScraper:
             frame_grabber.save_animation(image_path)
         else:
             frame_grabber.save_frame(image_path)
+        frame_grabber.cleanup()
         if 'images' in gallery_conf['compress_images']:
             optipng(image_path, gallery_conf['compress_images_args'])
         return [image_path]
@@ -176,6 +177,13 @@ class FrameGrabber:
         self._collected_images = []
         self._frames_to_grab = frame_grab_list[:]  # copy so original list is preserved
 
+    def cleanup(self):
+        from PyQt5.QtWidgets import QApplication
+        for child_widget in QApplication.allWidgets():
+            if hasattr(child_widget, 'close'):
+                child_widget.close()
+        QApplication.processEvents()
+
     def on_draw(self, _):
         if self._done:
             return  # Grab only once

vispy/util/tests/test_gallery_scraper.py

@@ -16,6 +16,8 @@ except ImportError:
 
 from ..gallery_scraper import VisPyGalleryScraper
 
+pytest.importorskip("PyQt5", reason="Gallery scraper only supports PyQt5")
+
 
 def _create_fake_block_vars(canvas):
     block_vars = {

vispy/version.py

@@ -1,5 +1,4 @@
-# coding: utf-8
 # file generated by setuptools_scm
 # don't change, don't track in version control
-__version__ = version = '0.12.0'
-__version_tuple__ = version_tuple = (0, 12, 0)
+__version__ = version = '0.14.0'
+__version_tuple__ = version_tuple = (0, 14, 0)

vispy/visuals/__init__.py

@@ -21,6 +21,7 @@ from .image_complex import ComplexImageVisual  # noqa
 from .gridmesh import GridMeshVisual  # noqa
 from .histogram import HistogramVisual  # noqa
 from .infinite_line import InfiniteLineVisual  # noqa
+from .instanced_mesh import InstancedMeshVisual  # noqa
 from .isocurve import IsocurveVisual  # noqa
 from .isoline import IsolineVisual  # noqa
 from .isosurface import IsosurfaceVisual  # noqa

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, 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.
@@ -387,6 +388,10 @@ class ShadingFilter(Filter):
     <https://github.com/vispy/vispy/blob/main/examples/basics/scene/mesh_shading.py>`_
     example script.
     """
+    _shaders = {
+        'vertex': shading_vertex_template,
+        'fragment': shading_fragment_template,
+    }
 
     def __init__(self, shading='flat',
                  ambient_coefficient=(1, 1, 1, 1),
@@ -412,8 +417,8 @@ class ShadingFilter(Filter):
 
         self._enabled = enabled
 
-        vfunc = Function(shading_vertex_template)
-        ffunc = Function(shading_fragment_template)
+        vfunc = Function(self._shaders['vertex'])
+        ffunc = Function(self._shaders['fragment'])
 
         self._normals = VertexBuffer(np.zeros((0, 3), dtype=np.float32))
         vfunc['normal'] = self._normals
@@ -572,6 +577,29 @@ class ShadingFilter(Filter):
         super()._detach(visual)
 
 
+instanced_shading_vertex_template = shading_vertex_template.replace(
+    "$normal",
+    "mat3($instance_transform_x, $instance_transform_y, $instance_transform_z) * $normal"
+)
+
+
+class InstancedShadingFilter(ShadingFilter):
+    """Shading filter modified for use with :class:`~vispy.visuals.InstancedMeshVisual`.
+
+    See :class:`ShadingFilter` for details and usage.
+    """
+    _shaders = {
+        'vertex': instanced_shading_vertex_template,
+        'fragment': ShadingFilter._shaders['fragment'],
+    }
+
+    def _attach(self, visual):
+        super()._attach(visual)
+        self.vshader['instance_transform_x'] = visual._instance_transforms_vbos[0]
+        self.vshader['instance_transform_y'] = visual._instance_transforms_vbos[1]
+        self.vshader['instance_transform_z'] = visual._instance_transforms_vbos[2]
+
+
 wireframe_vertex_template = """
 varying vec3 v_bc;
 
@@ -729,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