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

vispy/app/backends/_glfw.py

@@ -27,7 +27,7 @@ glfw = None
 try:
     import glfw
 except ImportError:
-    why_not = "Could not import glwf, you may need to `pip install glfw` first."
+    why_not = "Could not import glfw, you may need to `pip install glfw` first."
     available, testable, why_not, which = False, False, why_not, None
 except Exception as err:
     why_not = "Error importing glfw: " + str(err)
@@ -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/_pyglet.py

@@ -6,7 +6,7 @@
 
 from __future__ import division
 
-from distutils.version import LooseVersion
+from packaging.version import Version
 from time import sleep
 
 from ..base import (BaseApplicationBackend, BaseCanvasBackend,
@@ -23,7 +23,7 @@ USE_EGL = config['gl_backend'].lower().startswith('es')
 try:
     import pyglet
     version = pyglet.version
-    if LooseVersion(version) < LooseVersion('1.2'):
+    if Version(version) < Version('1.2'):
         help_ = ('You can install the latest pyglet using:\n    '
                  'pip install http://pyglet.googlecode.com/archive/tip.zip')
         raise ImportError('Pyglet version too old (%s), need >= 1.2\n%s'
@@ -271,6 +271,12 @@ class CanvasBackend(BaseCanvasBackend, _Window):
         w, h = self.get_size()
         return w, h
 
+    def _vispy_get_physical_size(self):
+        if self._vispy_canvas is None:
+            return
+        w, h = self.get_framebuffer_size()
+        return w, h
+
     def _vispy_get_position(self):
         x, y = self.get_location()
         return x, y

vispy/app/backends/_qt.py

@@ -22,11 +22,12 @@ known to cause unpredictable behavior and segfaults.
 from __future__ import division
 
 from time import sleep, time
+import math
 import os
 import sys
 import atexit
 import ctypes
-from distutils.version import LooseVersion
+from packaging.version import Version
 
 from ...util import logger
 from ..base import (BaseApplicationBackend, BaseCanvasBackend,
@@ -90,19 +91,19 @@ elif qt_lib == 'pyqt5':
     _check_imports('PyQt5')
     if not USE_EGL:
         from PyQt5.QtCore import QT_VERSION_STR
-        if LooseVersion(QT_VERSION_STR) >= '5.4.0':
+        if Version(QT_VERSION_STR) >= Version('5.4.0'):
             from PyQt5.QtWidgets import QOpenGLWidget as QGLWidget
             from PyQt5.QtGui import QSurfaceFormat as QGLFormat
             QT5_NEW_API = True
         else:
             from PyQt5.QtOpenGL import QGLWidget, QGLFormat
     from PyQt5 import QtGui, QtCore, QtWidgets, QtTest
-    QWidget, QApplication = QtWidgets.QWidget, QtWidgets.QApplication  # 
+    QWidget, QApplication = QtWidgets.QWidget, QtWidgets.QApplication  # Compat
 elif qt_lib == 'pyqt6':
     _check_imports('PyQt6')
     if not USE_EGL:
         from PyQt6.QtCore import QT_VERSION_STR
-        if LooseVersion(QT_VERSION_STR) >= '6.0.0':
+        if Version(QT_VERSION_STR) >= Version('6.0.0'):
             from PyQt6.QtOpenGLWidgets import QOpenGLWidget as QGLWidget
             from PyQt6.QtGui import QSurfaceFormat as QGLFormat
             PYQT6_API = True
@@ -114,7 +115,7 @@ elif qt_lib == 'pyside6':
     _check_imports('PySide6')
     if not USE_EGL:
         from PySide6.QtCore import __version__ as QT_VERSION_STR
-        if LooseVersion(QT_VERSION_STR) >= '6.0.0':
+        if Version(QT_VERSION_STR) >= Version('6.0.0'):
             from PySide6.QtOpenGLWidgets import QOpenGLWidget as QGLWidget
             from PySide6.QtGui import QSurfaceFormat as QGLFormat
             PYSIDE6_API = True
@@ -126,7 +127,7 @@ elif qt_lib == 'pyside2':
     _check_imports('PySide2')
     if not USE_EGL:
         from PySide2.QtCore import __version__ as QT_VERSION_STR
-        if LooseVersion(QT_VERSION_STR) >= '5.4.0':
+        if Version(QT_VERSION_STR) >= Version('5.4.0'):
             from PySide2.QtWidgets import QOpenGLWidget as QGLWidget
             from PySide2.QtGui import QSurfaceFormat as QGLFormat
             QT5_NEW_API = True
@@ -191,7 +192,7 @@ KEYMAP = {
     qt_keys.Key_Return: keys.ENTER,
     qt_keys.Key_Tab: keys.TAB,
 }
-if PYQT6_API:
+if PYQT6_API or PYSIDE6_API:
     BUTTONMAP = {
         QtCore.Qt.MouseButton.NoButton: 0,
         QtCore.Qt.MouseButton.LeftButton: 1,
@@ -278,11 +279,11 @@ def _set_config(c):
     glformat.setGreenBufferSize(c['green_size'])
     glformat.setBlueBufferSize(c['blue_size'])
     glformat.setAlphaBufferSize(c['alpha_size'])
-    if QT5_NEW_API or PYSIDE6_API:
+    if QT5_NEW_API:
         # Qt5 >= 5.4.0 - below options automatically enabled if nonzero.
         glformat.setSwapBehavior(glformat.DoubleBuffer if c['double_buffer']
                                  else glformat.SingleBuffer)
-    elif PYQT6_API:
+    elif PYQT6_API or PYSIDE6_API:
         glformat.setSwapBehavior(glformat.SwapBehavior.DoubleBuffer if c['double_buffer']
                                  else glformat.SwapBehavior.SingleBuffer)
     else:
@@ -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):
@@ -630,7 +655,7 @@ class QtBaseCanvasBackend(BaseCanvasBackend):
                      [qt_keyboard_modifiers.ControlModifier, keys.CONTROL],
                      [qt_keyboard_modifiers.AltModifier, keys.ALT],
                      [qt_keyboard_modifiers.MetaModifier, keys.META]):
-            if q & qtmod:
+            if qtmod & q:
                 mod += (v,)
         return mod
 

vispy/app/backends/_wx.py

@@ -376,6 +376,11 @@ class CanvasBackend(GLCanvas, BaseCanvasBackend):
         w, h = self.GetClientSize()
         return w, h
 
+    def _vispy_get_physical_size(self):
+        w, h = self.GetClientSize()
+        ratio = self.GetContentScaleFactor()
+        return int(w * ratio), int(h * ratio)
+
     def _vispy_get_position(self):
         if self._vispy_canvas is None:
             return
@@ -461,7 +466,7 @@ class TimerBackend(BaseTimerBackend):
         parent.Bind(wx.EVT_TIMER, self._vispy_timeout, self._timer)
 
     def _vispy_start(self, interval):
-        self._timer.Start(interval * 1000., False)
+        self._timer.Start(int(interval * 1000.), False)
 
     def _vispy_stop(self):
         self._timer.Stop()

vispy/app/canvas.py

@@ -606,7 +606,7 @@ class MouseEvent(Event):
         will return the button that started the drag (same thing as
         ``event.press_event.button``).
     buttons : [int, ...]
-        The list of buttons depressed during this event.
+        The list of buttons pressed during this event.
     modifiers : tuple of Key instances
         Tuple that specifies which modifier keys were pressed down at the
         time of the event (shift, control, alt, meta).
@@ -632,7 +632,9 @@ class MouseEvent(Event):
         Event.__init__(self, type, **kwargs)
         self._pos = np.array([0, 0]) if (pos is None) else np.array(pos)
         self._button = int(button) if (button is not None) else None
-        self._buttons = [] if (buttons is None) else buttons
+        # Explicitly add button to buttons if newly pressed, check #2344 for more reference
+        newly_pressed_buttons = [button] if button is not None and type == 'mouse_press' else []
+        self._buttons = [] if (buttons is None) else buttons + newly_pressed_buttons
         self._modifiers = tuple(modifiers or ())
         self._delta = np.zeros(2) if (delta is None) else np.array(delta)
         self._last_event = last_event

vispy/app/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.app import Canvas
+from vispy.app import Canvas, MouseEvent
 from vispy.visuals import ImageVisual
 from vispy.testing import requires_application
 from vispy.visuals.transforms import STTransform
@@ -68,4 +68,55 @@ def test_canvas_render(blend_func):
             np.testing.assert_allclose(rgba_result[..., 3], 255)
         else:
             # the alpha should have some transparency
+            # this part of this test fails on macOS 12 at the moment
+            # see https://github.com/vispy/vispy/pull/2324#issuecomment-1163350672
             assert (rgba_result[..., 3] != 255).any()
+
+
+@requires_application()
+@pytest.mark.parametrize(
+    'preset',
+    [
+        'opaque', 'additive', 'translucent',
+    ])
+def test_blend_presets(preset):
+    """Test blending presets a canvas to an array.
+
+    Different blending presets are used to test that they properly set
+    blend equations.
+
+    """
+    with Canvas(size=(125, 125), show=True, title='run') as c:
+        im1 = np.zeros((100, 100, 4)).astype(np.float32)
+        im1[:, :, 1] = 1
+        im1[:, :, 3] = .4
+        # Create the image
+        image1 = ImageVisual(im1)
+        image1.transform = STTransform(translate=(20, 20, -1))
+        image1.transforms.configure(canvas=c, viewport=(0, 0, 125, 125))
+        
+        gloo.set_state(blend_equation='min')
+        image1.set_gl_state(preset)
+
+        @c.events.draw.connect
+        def on_draw(ev):
+            gloo.clear('black')
+            gloo.set_viewport(0, 0, *c.physical_size)
+            image1.draw()
+            
+        rgba_result = c.render()
+        assert not np.allclose(rgba_result[..., :3], 0)
+
+
+@requires_application()
+@pytest.mark.parametrize("mouse_event_type, button, buttons, expected_button, expected_buttons", [
+    ('mouse_press', 1, [], 1, [1]),
+    ('mouse_release', 1, [1], 1, [1]),
+    # left click pressed and held, followed by a right click
+    ('mouse_press', 2, [1], 2, [1, 2]),
+    ('mouse_release', 2, [1, 2], 2, [1, 2]),
+])
+def test_mouse_event(mouse_event_type, button, buttons, expected_button, expected_buttons):
+    mev = MouseEvent(type=mouse_event_type, button=button, buttons=buttons)
+    assert mev.buttons == expected_buttons
+    assert mev.button == expected_button

vispy/app/tests/test_context.py

@@ -17,6 +17,8 @@ def test_context_properties():
         return  # cannot set more than once on Pyglet
     if a.backend_name.lower() == 'osmesa':
         return  # cannot set config on OSMesa
+    if 'pyqt5' in a.backend_name.lower() or 'pyqt6' in a.backend_name.lower() or 'pyside2' in a.backend_name.lower() or 'pyside6' in a.backend_name.lower():
+        pytest.xfail("Context sharing is not supported in PyQt5, PyQt6, PySide2, or PySide6 at this time.")
 
     # stereo, double buffer won't work on every sys
     configs = [dict(samples=4), dict(stencil_size=8),
@@ -68,9 +70,9 @@ def test_context_sharing():
         # Check while c1 is active
         check()
 
-        # pyqt5 does not currently support context sharing
-        if 'pyqt5' in c1.app.backend_name.lower() or 'pyqt6' in c1.app.backend_name.lower():
-            pytest.xfail("Context sharing is not supported in PyQt5 at this time.")
+        # pyqt5 does not currently support context sharing, pyside6 seg faults on app tests
+        if 'pyqt5' in c1.app.backend_name.lower() or 'pyqt6' in c1.app.backend_name.lower() or 'pyside2' in c1.app.backend_name.lower() or 'pyside6' in c1.app.backend_name.lower():
+            pytest.xfail("Context sharing is not supported in PyQt5, PyQt6, PySide2, or PySide6 at this time.")
 
         # Tkinter does not currently support context sharing
         if 'tk' in c1.app.backend_name.lower():

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

@@ -435,7 +435,7 @@ class Colormap(BaseColormap):
         if self.texture_map_data is None:
             return None
         interp = 'linear' if self.interpolation == 'linear' else 'nearest'
-        texture_LUT = vispy.gloo.Texture2D(np.zeros(self.texture_map_data.shape),
+        texture_LUT = vispy.gloo.Texture2D(np.zeros(self.texture_map_data.shape, dtype=np.float32),
                                            interpolation=interp)
         texture_LUT.set_data(self.texture_map_data, offset=None, copy=True)
         return texture_LUT
@@ -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: