vispy 0.9.5__cp38-cp38-win_amd64.whl → 0.14.0__cp38-cp38-win_amd64.whl

vispy/io/datasets.py

@@ -81,8 +81,8 @@ def load_spatial_filters(packed=True):
         Respective interpolation names, plus "Nearest" which does
         not require a filter but can still be used
     """
-    names = ("Bilinear", "Hanning", "Hamming", "Hermite",
-             "Kaiser", "Quadric", "Bicubic", "CatRom",
+    names = ("Linear", "Hanning", "Hamming", "Hermite",
+             "Kaiser", "Quadric", "Cubic", "CatRom",
              "Mitchell", "Spline16", "Spline36", "Gaussian",
              "Bessel", "Sinc", "Lanczos", "Blackman", "Nearest")
 

vispy/io/image.py

@@ -35,7 +35,7 @@ def _make_png(data, level=6):
         PNG formatted array
     """
     # Eventually we might want to use ext/png.py for this, but this
-    # routine *should* be faster b/c it's speacialized for our use case
+    # routine *should* be faster b/c it's specialized for our use case
 
     def mkchunk(data, name):
         if isinstance(data, np.ndarray):

vispy/io/stl.py

@@ -33,7 +33,7 @@ def load_stl(file_obj, file_type=None):
     file_type: not used
 
     Returns
-    ----------
+    -------
     loaded: kwargs for a Trimesh constructor with keys:
               vertices:     (n,3) float, vertices
               faces:        (m,3) int, indexes of vertices
@@ -65,7 +65,7 @@ def load_stl_binary(file_obj):
     file_obj: open file- like object
 
     Returns
-    ----------
+    -------
     loaded: kwargs for a Trimesh constructor with keys:
               vertices:     (n,3) float, vertices
               faces:        (m,3) int, indexes of vertices
@@ -124,7 +124,7 @@ def load_stl_ascii(file_obj):
     file_obj: open file- like object
 
     Returns
-    ----------
+    -------
     loaded: kwargs for a Trimesh constructor with keys:
               vertices:     (n,3) float, vertices
               faces:        (m,3) int, indexes of vertices

vispy/scene/cameras/base_camera.py

@@ -133,6 +133,8 @@ class BaseCamera(Node):
         viewbox.events.mouse_release.connect(self.viewbox_mouse_event)
         viewbox.events.mouse_move.connect(self.viewbox_mouse_event)
         viewbox.events.mouse_wheel.connect(self.viewbox_mouse_event)
+        viewbox.events.gesture_zoom.connect(self.viewbox_mouse_event)
+        viewbox.events.gesture_rotate.connect(self.viewbox_mouse_event)
         viewbox.events.resize.connect(self.viewbox_resize_event)
         # todo: also add key events! (and also on viewbox (they're missing)
 
@@ -144,6 +146,8 @@ class BaseCamera(Node):
         viewbox.events.mouse_release.disconnect(self.viewbox_mouse_event)
         viewbox.events.mouse_move.disconnect(self.viewbox_mouse_event)
         viewbox.events.mouse_wheel.disconnect(self.viewbox_mouse_event)
+        viewbox.events.gesture_zoom.disconnect(self.viewbox_mouse_event)
+        viewbox.events.gesture_rotate.disconnect(self.viewbox_mouse_event)
         viewbox.events.resize.disconnect(self.viewbox_resize_event)
 
     @property
@@ -224,8 +228,8 @@ class BaseCamera(Node):
     @fov.setter
     def fov(self, fov):
         fov = float(fov)
-        if fov < 0 or fov >= 180:
-            raise ValueError("fov must be between 0 and 180.")
+        if fov < 0 or fov > 180:
+            raise ValueError("fov must be 0 <= fov <= 180.")
         self._fov = fov
         self.view_changed()
 

vispy/scene/cameras/panzoom.py

@@ -132,8 +132,11 @@ class PanZoomCamera(BaseCamera):
 
     @property
     def rect(self):
-        """The rectangular border of the ViewBox visible area, expressed in
-        the coordinate system of the scene.
+        """The rectangular border of the ViewBox visible area.
+        
+        This is expressed in the coordinate system of the scene.
+        See :class:`~vispy.geometry.rect.Rect` for different ways this can
+        be specified.
 
         Note that the rectangle can have negative width or height, in
         which case the corresponding dimension is flipped (this flipping
@@ -162,17 +165,7 @@ class PanZoomCamera(BaseCamera):
         if not (isinstance(center, (tuple, list)) and len(center) in (2, 3)):
             raise ValueError('center must be a 2 or 3 element tuple')
         rect = Rect(self.rect) or Rect(*DEFAULT_RECT_TUPLE)
-        # Get half-ranges
-        x2 = rect.center[0]
-        y2 = rect.center[1]
-        # Apply new ranges
-        x1 = center[0]
-        y1 = center[1]
-        rect.left = x1 - x2
-        rect.right = x1 + x2
-        rect.bottom = y1 - y2
-        rect.top = y1 + y2
-        #
+        rect.center = center[:2]
         self.rect = rect
 
     def _set_range(self, init):
@@ -214,7 +207,10 @@ class PanZoomCamera(BaseCamera):
             center = self._scene_transform.imap(event.pos)
             self.zoom((1 + self.zoom_factor)**(-event.delta[1] * 30), center)
             event.handled = True
-
+        elif event.type == 'gesture_zoom':
+            center = self._scene_transform.imap(event.pos)
+            self.zoom(1 - event.scale, center)
+            event.handled = True
         elif event.type == 'mouse_move':
             if event.press_event is None:
                 return

vispy/scene/cameras/perspective.py

@@ -62,6 +62,12 @@ class PerspectiveCamera(BaseCamera):
             if self._distance is not None:
                 self._distance *= s
             self.view_changed()
+        elif event.type == 'gesture_zoom':
+            s = 1 - event.scale
+            self._scale_factor *= s
+            if self._distance is not None:
+                self._distance *= s
+            self.view_changed()
 
     @property
     def scale_factor(self):

vispy/scene/cameras/tests/test_cameras.py

@@ -0,0 +1,27 @@
+# -*- 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
+import pytest
+from vispy.scene.cameras import TurntableCamera
+from vispy.testing import run_tests_if_main
+
+
+@pytest.mark.parametrize(
+    "elevation, azimuth, roll, expected",
+    [
+        [0, 0, 0, np.eye(4)],
+        [90, 0, 0, [[1, 0, 0, 0], [0, 0, -1, 0], [0, 1, 0, 0], [0, 0, 0, 1]]],
+        [0, 90, 0, [[0, 1, 0, 0], [-1, 0, 0, 0], [0, 0, 1, 0], [0, 0, 0, 1]]],
+        [0, 0, 90, [[0, 0, -1, 0], [0, 1, 0, 0], [1, 0, 0, 0], [0, 0, 0, 1]]],
+    ],
+)
+def test_turntable_camera_transform(elevation, azimuth, roll, expected):
+    camera = TurntableCamera(elevation=elevation, azimuth=azimuth, roll=roll)
+    matrix = camera._get_rotation_tr()
+    np.testing.assert_allclose(matrix, expected, atol=1e-5)
+
+
+run_tests_if_main()

vispy/scene/cameras/tests/test_perspective.py

@@ -82,4 +82,41 @@ def test_panzoom_center():
         assert v.camera.center == (-12.8, -12.8, 0)
 
 
+@requires_application()
+def test_panzoom_gesture_zoom():
+    with TestingCanvas(size=(120, 200)) as canvas:
+        view = canvas.central_widget.add_view()
+        imdata = io.load_crate().astype('float32') / 255
+        scene.visuals.Image(imdata, parent=view.scene)
+        view.camera = scene.PanZoomCamera(aspect=1)
+
+        assert view.camera.rect.size == (1, 1)
+
+        canvas.events.touch(
+            type="gesture_zoom",
+            pos=(60, 100),
+            scale=-1.0,
+        )
+
+        assert view.camera.rect.size == (2, 2)
+
+
+@requires_application()
+def test_turntable_gesture_zoom():
+    with TestingCanvas(size=(120, 200)) as canvas:
+        view = canvas.central_widget.add_view()
+        imdata = io.load_crate().astype('float32') / 255
+        scene.visuals.Image(imdata, parent=view.scene)
+        view.camera = scene.TurntableCamera()
+
+        initial_scale_factor = view.camera.scale_factor
+        canvas.events.touch(
+            type="gesture_zoom",
+            pos=(60, 100),
+            scale=-1.0,
+        )
+
+        assert view.camera.scale_factor == 2 * initial_scale_factor
+
+
 run_tests_if_main()

vispy/scene/cameras/turntable.py

@@ -18,19 +18,26 @@ class TurntableCamera(Base3DRotationCamera):
     the ``center`` indicates the position to put at the center of the
     view.
 
+    When ``elevation`` and ``azimuth`` are set to 0, the camera
+    points along the +y axis.
+
     Parameters
     ----------
     fov : float
-        Field of view. Zero (default) means orthographic projection.
+        Field of view. 0.0 means orthographic projection,
+        default is 45.0 (some perspective)
     elevation : float
-        Elevation angle in degrees. Positive angles place the camera
-        above the cente point, negative angles place the camera below
-        the center point.
+        Elevation angle in degrees. The elevation angle represents a
+        rotation of the camera around the current scene x-axis. The
+        camera points along the x-y plane when the angle is 0.
     azimuth : float
-        Azimuth angle in degrees. Zero degrees places the camera on the
-        positive x-axis, pointing in the negative x direction.
+        Azimuth angle in degrees. The azimuth angle represents a
+        rotation of the camera around the scene z-axis according to the
+        right-hand screw rule. The camera points along the y-z plane when
+        the angle is 0.
     roll : float
-        Roll angle in degrees
+        Roll angle in degrees. The roll angle represents a rotation of
+        the camera around the current scene y-axis.
     distance : float | None
         The distance of the camera from the rotation point (only makes sense
         if fov > 0). If None (default) the distance is determined from the
@@ -51,24 +58,32 @@ class TurntableCamera(Base3DRotationCamera):
 
     """
 
-    _state_props = Base3DRotationCamera._state_props + ('elevation',
-                                                        'azimuth', 'roll')
-
-    def __init__(self, fov=45.0, elevation=30.0, azimuth=30.0, roll=0.0,
-                 distance=None, translate_speed=1.0, **kwargs):
+    _state_props = Base3DRotationCamera._state_props + ("elevation", "azimuth", "roll")
+
+    def __init__(
+        self,
+        fov=45.0,
+        elevation=30.0,
+        azimuth=30.0,
+        roll=0.0,
+        distance=None,
+        translate_speed=1.0,
+        **kwargs
+    ):
         super(TurntableCamera, self).__init__(fov=fov, **kwargs)
 
         # Set camera attributes
         self.azimuth = azimuth
         self.elevation = elevation
-        self.roll = roll  # interaction not implemented yet
+        self.roll = roll
         self.distance = distance  # None means auto-distance
         self.translate_speed = translate_speed
 
     @property
     def elevation(self):
-        """The angle of the camera in degrees above the horizontal (x, z)
-        plane.
+        """Get the camera elevation angle in degrees.
+        
+        The camera points along the x-y plane when the angle is 0.
         """
         return self._elevation
 
@@ -80,8 +95,9 @@ class TurntableCamera(Base3DRotationCamera):
 
     @property
     def azimuth(self):
-        """The angle of the camera in degrees around the y axis. An angle of
-        0 places the camera within the (y, z) plane.
+        """Get the camera azimuth angle in degrees.
+        
+        The camera points along the y-z plane when the angle is 0.
         """
         return self._azimuth
 
@@ -97,9 +113,7 @@ class TurntableCamera(Base3DRotationCamera):
 
     @property
     def roll(self):
-        """The angle of the camera in degrees around the z axis. An angle of
-        0 places puts the camera upright.
-        """
+        """Get the camera roll angle in degrees."""
         return self._roll
 
     @roll.setter
@@ -138,10 +152,12 @@ class TurntableCamera(Base3DRotationCamera):
     def _get_rotation_tr(self):
         """Return a rotation matrix based on camera parameters"""
         up, forward, right = self._get_dim_vectors()
-        return np.dot(
-            transforms.rotate(self.elevation, -right),
-            transforms.rotate(self.azimuth, up)
+        matrix = (
+            transforms.rotate(self.elevation, -right)
+            .dot(transforms.rotate(self.azimuth, up))
+            .dot(transforms.rotate(self.roll, forward))
         )
+        return matrix
 
     def _dist_to_trans(self, dist):
         """Convert mouse x, y movement into x, y, z translations"""

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'):
@@ -423,7 +425,7 @@ class Node(object):
             If true, add information about node transform types.
 
         Returns
-        ----------
+        -------
         tree : str
             The tree diagram.
         """
@@ -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_canvas.py

@@ -2,7 +2,7 @@
 # Copyright (c) Vispy Development Team. All Rights Reserved.
 # Distributed under the (new) BSD License. See LICENSE.txt for more info.
 
-from vispy import scene
+from vispy import gloo, scene
 from vispy.testing import requires_application, TestingCanvas
 from vispy.visuals.transforms import STTransform
 
@@ -88,3 +88,32 @@ def test_picking_basic():
             assert len(picked_visuals) == 2
             assert any(isinstance(vis, scene.ViewBox) for vis in picked_visuals)
             assert any(isinstance(vis, scene.Line) for vis in picked_visuals)
+
+
+@requires_application()
+@pytest.mark.parametrize(
+    'preset',
+    [
+        'opaque', 'additive', 'translucent',
+    ])
+def test_blend_presets(preset):
+    """Test blending presets render a canvas to an array.
+
+    Different blending presets are used to test that they properly set
+    blend equations.
+
+    """
+    with TestingCanvas(size=(125, 125), show=True, title='run') as c:
+        view = c.central_widget.add_view()
+        im1 = np.zeros((100, 100, 4)).astype(np.float32)
+        im1[:, :, 1] = 1
+        im1[:, :, 3] = .4
+        # Create the image
+        image1 = scene.visuals.Image(im1, parent=view.scene)
+        image1.transform = STTransform(translate=(20, 20, -1))
+
+        gloo.set_state(blend_equation='min')
+        image1.set_gl_state(preset)
+
+        rgba_result = c.render()
+        assert not np.allclose(rgba_result[..., :3], 0)

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
@@ -242,7 +245,9 @@ GridLines = create_visual_node(visuals.GridLinesVisual)
 GridMesh = create_visual_node(visuals.GridMeshVisual)
 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/scene/widgets/viewbox.py

@@ -3,6 +3,7 @@
 # Distributed under the (new) BSD License. See LICENSE.txt for more info.
 
 from __future__ import division
+from typing import Union
 
 import numpy as np
 
@@ -67,7 +68,7 @@ class ViewBox(Widget):
             raise TypeError('Argument "camera" must be None, str, or Camera.')
 
     @property
-    def camera(self):
+    def camera(self) -> BaseCamera:
         """Get/set the Camera in use by this ViewBox
 
         If a string is given (e.g. 'panzoom', 'turntable', 'fly'). A
@@ -84,7 +85,7 @@ class ViewBox(Widget):
         return self._camera
 
     @camera.setter
-    def camera(self, cam):
+    def camera(self, cam: Union[str, BaseCamera]):
         if isinstance(cam, str):
             # Try to select an existing camera
             for child in self.scene.children:

vispy/testing/_runners.py

@@ -219,24 +219,18 @@ try:
     faulthandler.enable()
 except Exception:
     pass
+from vispy.util.gallery_scraper import get_canvaslike_from_globals, FrameGrabber
 os.environ['VISPY_IGNORE_OLD_VERSION'] = 'true'
+os.environ['_VISPY_RUNNING_GALLERY_EXAMPLES'] = 'true'
 import {0}
 
-if hasattr({0}, 'canvas'):
-    canvas = {0}.canvas
-elif hasattr({0}, 'Canvas'):
-    canvas = {0}.Canvas()
-elif hasattr({0}, 'fig'):
-    canvas = {0}.fig
-else:
+canvas_or_widget = get_canvaslike_from_globals({0}.__dict__)
+if canvas_or_widget is None:
     raise RuntimeError('Bad example formatting: fix or add `# vispy: testskip`'
                        ' to the top of the file.')
 
-with canvas as c:
-    for _ in range(5):
-        c.update()
-        c.app.process_events()
-        time.sleep(1./60.)
+frame_grabber = FrameGrabber(canvas_or_widget, [1, 2, 3, 4, 5])
+frame_grabber.collect_frames()
 """
 
 bad_examples = []