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

vispy/app/backends/_glfw.py

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

vispy/app/backends/_qt.py

@@ -22,6 +22,7 @@ known to cause unpredictable behavior and segfaults.
 from __future__ import division
 
 from time import sleep, time
+import math
 import os
 import sys
 import atexit
@@ -410,17 +411,10 @@ class QtBaseCanvasBackend(BaseCanvasBackend):
             # either not PyQt5 backend or no parent window available
             pass
 
-        # Activate touch and gesture.
-        # NOTE: we only activate touch on OS X because there seems to be
-        # problems on Ubuntu computers with touchscreen.
-        # See https://github.com/vispy/vispy/pull/1143
-        if sys.platform == 'darwin':
-            if PYQT6_API:
-                self.setAttribute(QtCore.Qt.WidgetAttribute.WA_AcceptTouchEvents)
-                self.grabGesture(QtCore.Qt.GestureType.PinchGesture)
-            else:
-                self.setAttribute(QtCore.Qt.WA_AcceptTouchEvents)
-                self.grabGesture(QtCore.Qt.PinchGesture)
+        # QNativeGestureEvent does not keep track of last or total
+        # values like QGestureEvent does
+        self._native_gesture_scale_values = []
+        self._native_gesture_rotation_values = []
 
     def screen_changed(self, new_screen):
         """Window moved from one display to another, resize canvas.
@@ -563,50 +557,81 @@ class QtBaseCanvasBackend(BaseCanvasBackend):
     def keyReleaseEvent(self, ev):
         self._keyEvent(self._vispy_canvas.events.key_release, ev)
 
+    def _handle_native_gesture_event(self, ev):
+        if self._vispy_canvas is None:
+            return
+        t = ev.gestureType()
+        # this is a workaround for what looks like a Qt bug where
+        # QNativeGestureEvent gives the wrong local position.
+        # See: https://bugreports.qt.io/browse/QTBUG-59595
+        try:
+            pos = self.mapFromGlobal(ev.globalPosition().toPoint())
+        except AttributeError:
+            # globalPos is deprecated in Qt6
+            pos = self.mapFromGlobal(ev.globalPos())
+        pos = pos.x(), pos.y()
+
+        if t == QtCore.Qt.NativeGestureType.BeginNativeGesture:
+            self._vispy_canvas.events.touch(
+                type='gesture_begin',
+                pos=_get_event_xy(ev),
+            )
+        elif t == QtCore.Qt.NativeGestureType.EndNativeGesture:
+            self._native_touch_total_rotation = []
+            self._native_touch_total_scale = []
+            self._vispy_canvas.events.touch(
+                type='gesture_end',
+                pos=_get_event_xy(ev),
+            )
+        elif t == QtCore.Qt.NativeGestureType.RotateNativeGesture:
+            angle = ev.value()
+            last_angle = (
+                self._native_gesture_rotation_values[-1]
+                if self._native_gesture_rotation_values
+                else None
+            )
+            self._native_gesture_rotation_values.append(angle)
+            total_rotation_angle = math.fsum(self._native_gesture_rotation_values)
+            self._vispy_canvas.events.touch(
+                type="gesture_rotate",
+                pos=pos,
+                rotation=angle,
+                last_rotation=last_angle,
+                total_rotation_angle=total_rotation_angle,
+            )
+        elif t == QtCore.Qt.NativeGestureType.ZoomNativeGesture:
+            scale = ev.value()
+            last_scale = (
+                self._native_gesture_scale_values[-1]
+                if self._native_gesture_scale_values
+                else None
+            )
+            self._native_gesture_scale_values.append(scale)
+            total_scale_factor = math.fsum(self._native_gesture_scale_values)
+            self._vispy_canvas.events.touch(
+                type="gesture_zoom",
+                pos=pos,
+                last_scale=last_scale,
+                scale=scale,
+                total_scale_factor=total_scale_factor,
+            )
+        # QtCore.Qt.NativeGestureType.PanNativeGesture
+        # Qt6 docs seem to imply this is only supported on Wayland but I have
+        # not been able to test it.
+        # Two finger pan events are anyway converted to scroll/wheel events.
+        # On macOS, more fingers are usually swallowed by the OS (by spaces,
+        # mission control, etc.).
+
     def event(self, ev):
         out = super(QtBaseCanvasBackend, self).event(ev)
-        t = ev.type()
-
-        qt_event_types = QtCore.QEvent.Type if PYQT6_API else QtCore.QEvent
-        # Two-finger pinch.
-        if t == qt_event_types.TouchBegin:
-            self._vispy_canvas.events.touch(type='begin')
-        if t == qt_event_types.TouchEnd:
-            self._vispy_canvas.events.touch(type='end')
-        if t == qt_event_types.Gesture:
-            pinch_gesture = QtCore.Qt.GestureType.PinchGesture if PYQT6_API else QtCore.Qt.PinchGesture
-            gesture = ev.gesture(pinch_gesture)
-            if gesture:
-                (x, y) = _get_qpoint_pos(gesture.centerPoint())
-                scale = gesture.scaleFactor()
-                last_scale = gesture.lastScaleFactor()
-                rotation = gesture.rotationAngle()
-                self._vispy_canvas.events.touch(
-                    type="pinch",
-                    pos=(x, y),
-                    last_pos=None,
-                    scale=scale,
-                    last_scale=last_scale,
-                    rotation=rotation,
-                    total_rotation_angle=gesture.totalRotationAngle(),
-                    total_scale_factor=gesture.totalScaleFactor(),
-                )
-        # General touch event.
-        elif t == qt_event_types.TouchUpdate:
-            if qt_lib == 'pyqt6' or qt_lib == 'pyside6':
-                points = ev.points()
-                # These variables are lists of (x, y) coordinates.
-                pos = [_get_qpoint_pos(p.position()) for p in points]
-                lpos = [_get_qpoint_pos(p.lastPosition()) for p in points]
-            else:
-                points = ev.touchPoints()
-                # These variables are lists of (x, y) coordinates.
-                pos = [_get_qpoint_pos(p.pos()) for p in points]
-                lpos = [_get_qpoint_pos(p.lastPos()) for p in points]
-            self._vispy_canvas.events.touch(type='touch',
-                                            pos=pos,
-                                            last_pos=lpos,
-                                            )
+
+        # QNativeGestureEvent is Qt 5+
+        if (
+            (QT5_NEW_API or PYSIDE6_API or PYQT6_API)
+            and isinstance(ev, QtGui.QNativeGestureEvent)
+        ):
+            self._handle_native_gesture_event(ev)
+
         return out
 
     def _keyEvent(self, func, ev):

vispy/color/color_array.py

@@ -21,7 +21,7 @@ def _string_to_rgb(color):
     if not color.startswith('#'):
         if color.lower() not in _color_dict:
             raise ValueError('Color "%s" unknown' % color)
-        color = _color_dict[color]
+        color = _color_dict[color.lower()]
         assert color[0] == '#'
     # hex color
     color = color[1:]
@@ -163,6 +163,13 @@ class ColorArray(object):
         """Helper to get the class name once it's been created"""
         return cls.__name__
 
+    def __array__(self, dtype=None):
+        """Get a standard numpy array representing RGBA."""
+        rgba = self.rgba
+        if dtype is not None:
+            rgba = rgba.astype(dtype)
+        return rgba
+
     def __len__(self):
         return self._rgba.shape[0]
 

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/geometry/meshdata.py

@@ -19,6 +19,56 @@ def _fix_colors(colors):
     return colors
 
 
+def _compute_face_normals(vertices):
+    if vertices.shape[1:] != (3, 3):
+        raise ValueError("Expected (N, 3, 3) array of vertices repeated on"
+                         f" the triangle corners, got {vertices.shape}.")
+    edges1 = vertices[:, 1] - vertices[:, 0]
+    edges2 = vertices[:, 2] - vertices[:, 0]
+    return np.cross(edges1, edges2)
+
+
+def _repeat_face_normals_on_corners(normals):
+    if normals.shape[1:] != (3,):
+        raise ValueError("Expected (F, 3) array of face normals, got"
+                         f" {normals.shape}.")
+    n_corners_in_face = 3
+    new_shape = (normals.shape[0], n_corners_in_face, normals.shape[1])
+    return np.repeat(normals, n_corners_in_face, axis=0).reshape(new_shape)
+
+
+def _compute_vertex_normals(face_normals, faces, vertices):
+    if face_normals.shape[1:] != (3,):
+        raise ValueError("Expected (F, 3) array of face normals, got"
+                         f" {face_normals.shape}.")
+    if faces.shape[1:] != (3,):
+        raise ValueError("Expected (F, 3) array of face vertex indices, got"
+                         f" {faces.shape}.")
+    if vertices.shape[1:] != (3,):
+        raise ValueError("Expected (N, 3) array of vertices, got"
+                         f" {vertices.shape}.")
+
+    vertex_normals = np.zeros_like(vertices)
+    n_corners_in_triangle = 3
+    face_normals_repeated_on_corners = np.repeat(face_normals,
+                                                 n_corners_in_triangle,
+                                                 axis=0)
+    # NOTE: The next line is equivalent to
+    #
+    #   vertex_normals[self._faces.ravel()] += face_normals_repeated_on_corners
+    #
+    # except that it accumulates the values from the right hand side at
+    # repeated indices on the left hand side, instead of overwritting them,
+    # like in the above.
+    np.add.at(vertex_normals, faces.ravel(), face_normals_repeated_on_corners)
+
+    norms = np.sqrt((vertex_normals**2).sum(axis=1))
+    nonzero_norms = norms > 0
+    vertex_normals[nonzero_norms] /= norms[nonzero_norms][:, None]
+
+    return vertex_normals
+
+
 class MeshData(object):
     """
     Class for storing and operating on 3D mesh data.
@@ -141,7 +191,7 @@ class MeshData(object):
                 self._compute_edges(indexed='faces')
             return self._edges_indexed_by_faces
         else:
-            raise Exception("Invalid indexing mode. Accepts: None, 'faces'")
+            raise ValueError("Invalid indexing mode. Accepts: None, 'faces'")
 
     def set_faces(self, faces):
         """Set the faces
@@ -191,7 +241,7 @@ class MeshData(object):
                     self._vertices[self.get_faces()]
             return self._vertices_indexed_by_faces
         else:
-            raise Exception("Invalid indexing mode. Accepts: None, 'faces'")
+            raise ValueError("Invalid indexing mode. Accepts: None, 'faces'")
 
     def get_bounds(self):
         """Get the mesh bounds
@@ -234,7 +284,7 @@ class MeshData(object):
             if verts is not None:
                 self._vertices_indexed_by_faces = verts
         else:
-            raise Exception("Invalid indexing mode. Accepts: None, 'faces'")
+            raise ValueError("Invalid indexing mode. Accepts: None, 'faces'")
 
         if reset_normals:
             self.reset_normals()
@@ -293,22 +343,19 @@ class MeshData(object):
         normals : ndarray
             The normals.
         """
+        if indexed not in (None, 'faces'):
+            raise ValueError("Invalid indexing mode. Accepts: None, 'faces'")
+
         if self._face_normals is None:
-            v = self.get_vertices(indexed='faces')
-            self._face_normals = np.cross(v[:, 1] - v[:, 0],
-                                          v[:, 2] - v[:, 0])
+            vertices = self.get_vertices(indexed='faces')
+            self._face_normals = _compute_face_normals(vertices)
 
-        if indexed is None:
-            return self._face_normals
-        elif indexed == 'faces':
-            if self._face_normals_indexed_by_faces is None:
-                norms = np.empty((self._face_normals.shape[0], 3, 3),
-                                 dtype=np.float32)
-                norms[:] = self._face_normals[:, np.newaxis, :]
-                self._face_normals_indexed_by_faces = norms
-            return self._face_normals_indexed_by_faces
-        else:
-            raise Exception("Invalid indexing mode. Accepts: None, 'faces'")
+        if indexed == 'faces' and self._face_normals_indexed_by_faces is None:
+            self._face_normals_indexed_by_faces = \
+                _repeat_face_normals_on_corners(self._face_normals)
+
+        return (self._face_normals if indexed is None
+                else self._face_normals_indexed_by_faces)
 
     def get_vertex_normals(self, indexed=None):
         """Get vertex normals
@@ -326,29 +373,20 @@ class MeshData(object):
         normals : ndarray
             The normals.
         """
+        if indexed not in (None, 'faces'):
+            raise ValueError("Invalid indexing mode. Accepts: None, 'faces'")
+
         if self._vertex_normals is None:
-            faceNorms = self.get_face_normals()
-            vertFaces = self.get_vertex_faces()
-            self._vertex_normals = np.empty(self._vertices.shape,
-                                            dtype=np.float32)
-            for vindex in range(self._vertices.shape[0]):
-                faces = vertFaces[vindex]
-                if len(faces) == 0:
-                    self._vertex_normals[vindex] = (0, 0, 0)
-                    continue
-                norms = faceNorms[faces]  # get all face normals
-                norm = norms.sum(axis=0)  # sum normals
-                renorm = (norm**2).sum()**0.5
-                if renorm > 0:
-                    norm /= renorm
-                self._vertex_normals[vindex] = norm
+            face_normals = self.get_face_normals()
+            faces = self.get_faces()
+            vertices = self.get_vertices()
+            self._vertex_normals = _compute_vertex_normals(face_normals, faces,
+                                                           vertices)
 
         if indexed is None:
             return self._vertex_normals
         elif indexed == 'faces':
             return self._vertex_normals[self.get_faces()]
-        else:
-            raise Exception("Invalid indexing mode. Accepts: None, 'faces'")
 
     def get_vertex_colors(self, indexed=None):
         """Get vertex colors
@@ -373,7 +411,7 @@ class MeshData(object):
                     self._vertex_colors[self.get_faces()]
             return self._vertex_colors_indexed_by_faces
         else:
-            raise Exception("Invalid indexing mode. Accepts: None, 'faces'")
+            raise ValueError("Invalid indexing mode. Accepts: None, 'faces'")
 
     def get_vertex_values(self, indexed=None):
         """Get vertex colors
@@ -398,7 +436,7 @@ class MeshData(object):
                     self._vertex_values[self.get_faces()]
             return self._vertex_values_indexed_by_faces
         else:
-            raise Exception("Invalid indexing mode. Accepts: None, 'faces'")
+            raise ValueError("Invalid indexing mode. Accepts: None, 'faces'")
 
     def set_vertex_colors(self, colors, indexed=None):
         """Set the vertex color array
@@ -488,7 +526,7 @@ class MeshData(object):
                     self._face_colors.reshape(Nf, 1, 4)
             return self._face_colors_indexed_by_faces
         else:
-            raise Exception("Invalid indexing mode. Accepts: None, 'faces'")
+            raise ValueError("Invalid indexing mode. Accepts: None, 'faces'")
 
     def set_face_colors(self, colors, indexed=None):
         """Set the face color array
@@ -611,7 +649,7 @@ class MeshData(object):
                 raise Exception("MeshData cannot generate edges--no faces in "
                                 "this data.")
         else:
-            raise Exception("Invalid indexing mode. Accepts: None, 'faces'")
+            raise ValueError("Invalid indexing mode. Accepts: None, 'faces'")
 
     def save(self):
         """Serialize this mesh to a string appropriate for disk storage

vispy/geometry/tests/test_meshdata.py

@@ -31,4 +31,76 @@ def test_meshdata():
     assert_array_equal(square_edges, mesh.get_edges())
 
 
+def test_vertex_normals_indexed_none():
+    dtype_float = np.float32
+    dtype_int = np.int64
+    vertices = np.array([[0, 0, 0], [1, 0, 0], [0, 1, 0], [0, 0, 1]],
+                        dtype=dtype_float)
+    faces = np.array([[0, 2, 1], [0, 3, 2], [0, 1, 3]], dtype=dtype_int)
+    mesh = MeshData(vertices=vertices, faces=faces)
+    vertex_normals_unnormalized = np.array(
+        [[-1, -1, -1], [0, -1, -1], [-1, 0, -1], [-1, -1, 0]],
+        dtype=dtype_float)
+    norms = np.sqrt((vertex_normals_unnormalized**2).sum(axis=1,
+                                                         keepdims=True))
+    expected_vertex_normals = vertex_normals_unnormalized / norms
+
+    computed_vertex_normals = mesh.get_vertex_normals(indexed=None)
+
+    assert_array_equal(expected_vertex_normals, computed_vertex_normals)
+
+
+def test_vertex_normals_indexed_faces():
+    dtype_float = np.float32
+    dtype_int = np.int64
+    vertices = np.array([[0, 0, 0], [1, 0, 0], [0, 1, 0], [0, 0, 1]],
+                        dtype=dtype_float)
+    faces = np.array([[0, 2, 1], [0, 3, 2], [0, 1, 3]], dtype=dtype_int)
+    mesh = MeshData(vertices=vertices, faces=faces)
+    vertex_normals_unnormalized = np.array(
+        [[-1, -1, -1], [0, -1, -1], [-1, 0, -1], [-1, -1, 0]],
+        dtype=dtype_float)
+    norms = np.sqrt((vertex_normals_unnormalized**2).sum(axis=1,
+                                                         keepdims=True))
+    vertex_normals = vertex_normals_unnormalized / norms
+    expected_vertex_normals = vertex_normals[faces]
+
+    computed_vertex_normals = mesh.get_vertex_normals(indexed="faces")
+
+    assert_array_equal(expected_vertex_normals, computed_vertex_normals)
+
+
+def test_face_normals_indexed_none():
+    dtype_float = np.float32
+    dtype_int = np.int64
+    vertices = np.array([[0, 0, 0], [1, 0, 0], [0, 1, 0], [0, 0, 1]],
+                        dtype=dtype_float)
+    faces = np.array([[0, 2, 1], [0, 3, 2], [0, 1, 3]], dtype=dtype_int)
+    mesh = MeshData(vertices=vertices, faces=faces)
+    expected_face_normals = np.array([[0, 0, -1], [-1, 0, 0], [0, -1, 0]],
+                                     dtype=dtype_float)
+
+    computed_face_normals = mesh.get_face_normals(indexed=None)
+
+    assert_array_equal(expected_face_normals, computed_face_normals)
+
+
+def test_face_normals_indexed_faces():
+    dtype_float = np.float32
+    dtype_int = np.int64
+    vertices = np.array([[0, 0, 0], [1, 0, 0], [0, 1, 0], [0, 0, 1]],
+                        dtype=dtype_float)
+    faces = np.array([[0, 2, 1], [0, 3, 2], [0, 1, 3]], dtype=dtype_int)
+    mesh = MeshData(vertices=vertices, faces=faces)
+    expected_face_normals = np.array([
+        [[0, 0, -1], [0, 0, -1], [0, 0, -1]],
+        [[-1, 0, 0], [-1, 0, 0], [-1, 0, 0]],
+        [[0, -1, 0], [0, -1, 0], [0, -1, 0]]],
+        dtype=dtype_float)
+
+    computed_face_normals = mesh.get_face_normals(indexed="faces")
+
+    assert_array_equal(expected_face_normals, computed_face_normals)
+
+
 run_tests_if_main()

vispy/gloo/gl/_constants.py

@@ -326,7 +326,7 @@ GL_ZERO = Enum('GL_ZERO', 0)
 
 
 ENUM_MAP = {}
-for ob in list(globals().values()):
-    if repr(ob).startswith('GL_'):
+for var_name, ob in list(globals().items()):
+    if var_name.startswith('GL_'):
         ENUM_MAP[int(ob)] = ob
-del ob
+del ob, var_name

vispy/gloo/program.py

@@ -502,7 +502,7 @@ class Program(GLObject):
         sizes = [a.size for a in attrs]
         if not all(s == sizes[0] for s in sizes[1:]):
             msg = '\n'.join([f'{str(a)}: {a.size}' for a in attrs])
-            raise RuntimeError('All attributes must have the same size, got:\n{msg}')
+            raise RuntimeError(f'All attributes must have the same size, got:\n{msg}')
 
         attrs_with_div = [a for a in attributes if a not in attrs]
         if attrs_with_div:

vispy/gloo/texture.py

@@ -33,17 +33,22 @@ 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
 
 
-def downcast_to_32bit_if_needed(data, copy=False):
+def downcast_to_32bit_if_needed(data, copy=False, dtype=None):
     """Downcast to 32bit dtype if necessary."""
-    dtype = np.dtype(data.dtype)
+    if dtype is None:
+        dtype = data.dtype
+    dtype = np.dtype(dtype)
     if dtype.itemsize > 4:
         warnings.warn(
             f"GPUs can't support dtypes bigger than 32-bit, but got '{dtype}'. "
-            "Precision will be lost due to downcasting to 32-bit."
+            "Precision will be lost due to downcasting to 32-bit.",
+            stacklevel=2,
         )
 
     size = min(dtype.itemsize, 4)

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

vispy/scene/cameras/panzoom.py

@@ -207,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_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()