vispy 0.15.0__cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl

vispy/app/backends/_jupyter_rfb.py

@@ -0,0 +1,278 @@
+import asyncio
+
+from ..base import BaseApplicationBackend, BaseCanvasBackend, BaseTimerBackend
+from ...app import Timer
+from ...util import keys
+from ._offscreen_util import OffscreenContext, FrameBufferHelper
+
+
+try:
+    from jupyter_rfb import RemoteFrameBuffer
+except Exception:
+    RemoteFrameBuffer = object
+    _msg = 'The jupyter_rfb backend relies on a the jupyter_rfb library: ``pip install jupyter_rfb``'
+    available, testable, why_not, which = False, False, _msg, None
+else:
+    available, testable, why_not = True, False, None
+    which = "jupyter_rfb"
+
+
+# -------------------------------------------------------------- capability ---
+
+capability = dict(
+    title=False,
+    size=True,
+    position=False,
+    show=False,
+    vsync=False,
+    resizable=True,
+    decorate=False,
+    fullscreen=False,
+    context=False,  # Could work, but not implemented
+    multi_window=True,
+    scroll=True,
+    parent=False,  # ipywidgets has layouts, but has no concept of parents
+    always_on_top=False,
+)
+
+
+# ------------------------------------------------------- set_configuration ---
+
+# The configuration mostly applies to the framebuffer. So if we'd want
+# to implement some of that, we'd probably have to apply it to the FBO.
+
+
+# ------------------------------------------------------------- application ---
+
+
+class ApplicationBackend(BaseApplicationBackend):
+
+    def __init__(self):
+        super().__init__()
+
+    def _vispy_get_backend_name(self):
+        return 'jupyter_rfb'
+
+    def _vispy_process_events(self):
+        raise RuntimeError("Cannot process events while asyncio event-loop is running.")
+
+    def _vispy_run(self):
+        pass  # We're in IPython; don't enter a mainloop or we'll block!
+
+    def _vispy_quit(self):
+        pass
+
+    def _vispy_get_native_app(self):
+        return asyncio
+
+
+# ------------------------------------------------------------------ canvas ---
+
+class CanvasBackend(BaseCanvasBackend, RemoteFrameBuffer):
+
+    _double_click_supported = True
+
+    def __init__(self, vispy_canvas, **kwargs):
+        BaseCanvasBackend.__init__(self, vispy_canvas)
+        RemoteFrameBuffer.__init__(self)
+        # Use a context per canvas, because we seem to make assumptions
+        # about OpenGL state being local to the canvas.
+        self._context = OffscreenContext()  # OffscreenContext.get_global_instance()
+        self._helper = FrameBufferHelper()
+        self._loop = asyncio.get_event_loop()
+        self._logical_size = 1, 1
+        self._physical_size = 1, 1
+        self._lifecycle = 0  # 0: not initialized, 1: initialized, 2: closed
+        # Init more based on kwargs (could maybe handle, title, show, context)
+        self._vispy_set_size(*kwargs["size"])
+        self.resizable = kwargs["resizable"]
+        # Need a first update
+        self._vispy_update()
+
+    def handle_event(self, ev):
+        type = ev["event_type"]
+        if type == "resize":
+            # Note that jupyter_rfb already throttles this event
+            w, h, r = ev["width"], ev["height"], ev["pixel_ratio"]
+            self._logical_size = w, h
+            self._physical_size = int(w * r), int(h * r)
+            self._helper.set_physical_size(*self._physical_size)
+            self._loop.call_soon(self._emit_resize_event)
+            self._vispy_update()  # make sure to schedule a new draw
+        elif type == "pointer_down":
+            self._vispy_mouse_press(
+                native=ev,
+                pos=(ev["x"], ev["y"]),
+                button=ev["button"],
+                modifiers=self._modifiers(ev),
+            )
+        elif type == "pointer_up":
+            self._vispy_mouse_release(
+                native=ev,
+                pos=(ev["x"], ev["y"]),
+                button=ev["button"],
+                modifiers=self._modifiers(ev),
+            )
+        elif type == "pointer_move":
+            self._vispy_mouse_move(
+                native=ev,
+                pos=(ev["x"], ev["y"]),
+                button=ev["button"],
+                modifiers=self._modifiers(ev),
+            )
+        elif type == "double_click":
+            self._vispy_mouse_double_click(
+                native=ev,
+                pos=(ev["x"], ev["y"]),
+                button=ev["button"],
+                modifiers=self._modifiers(ev),
+            )
+        elif type == "wheel":
+            self._vispy_canvas.events.mouse_wheel(
+                native=ev,
+                pos=(ev["x"], ev["y"]),
+                delta=(ev["dx"] / 100, - ev["dy"] / 100),
+                modifiers=self._modifiers(ev),
+            )
+        elif type == "key_down":
+            # The special key names are all (most?) the same
+            # But the key is actually more like tex, e.g. shift + 3 becomes "#"
+            self._vispy_canvas.events.key_press(
+                native=ev,
+                key=keys.Key(ev["key"]),
+                modifiers=self._modifiers(ev),
+                text=ev["key"],
+            )
+        elif type == "key_up":
+            self._vispy_canvas.events.key_release(
+                native=ev,
+                key=keys.Key(ev["key"]),
+                modifiers=self._modifiers(ev),
+                text=ev["key"],
+            )
+        elif type == "close":
+            self._lifecycle = 2
+            self._context.close()
+            _stop_timers(self._vispy_canvas)
+        else:
+            pass  # event ignored / unknown
+
+    def _modifiers(self, ev):
+        return tuple(getattr(keys, m.upper()) for m in ev["modifiers"])
+
+    def _emit_resize_event(self):
+        self._vispy_canvas.events.resize(
+            size=self._logical_size,
+            physical_size=self._physical_size,
+        )
+
+    def get_frame(self):
+        # This gets automatically called by the RFB widget
+
+        # Only draw if the draw region is not null
+        if self._physical_size[0] <= 1 or self._physical_size[1] <= 1:
+            return None
+
+        # Handle initialization
+        if not self._lifecycle:
+            self._lifecycle = 1
+            self._vispy_canvas.set_current()
+            self._vispy_canvas.events.initialize()
+            self._emit_resize_event()
+
+        # Draw and obtain result
+        self._vispy_canvas.set_current()
+        with self._helper:
+            self._vispy_canvas.events.draw(region=None)
+            array = self._helper.get_frame()
+
+        # Flush commands here to clean up - otherwise we get errors related to
+        # framebuffers not existin.
+        self._vispy_canvas.context.flush_commands()
+
+        return array
+
+    def _vispy_warmup(self):
+        self._vispy_canvas.set_current()
+
+    def _vispy_set_current(self):
+        self._context.make_current()
+
+    def _vispy_swap_buffers(self):
+        pass
+
+    def _vispy_set_title(self, title):
+        pass
+
+    def _vispy_set_size(self, w, h):
+        self.css_width = f"{w}px"
+        self.css_height = f"{h}px"
+
+    def _vispy_set_position(self, x, y):
+        pass
+
+    def _vispy_set_visible(self, visible):
+        if not visible:
+            raise NotImplementedError("Cannot hide the RFB widget")
+
+    def _vispy_set_fullscreen(self, fullscreen):
+        raise NotImplementedError()
+
+    def _vispy_update(self):
+        self.request_draw()
+
+    def _vispy_close(self):
+        # ipywidget.Widget.close()  ->  closes the comm and removes all views
+        self.close()
+
+    def _vispy_get_size(self):
+        return self._logical_size
+
+    def _vispy_get_physical_size(self):
+        return self._physical_size
+
+    def _vispy_get_position(self):
+        return 0, 0
+
+    def _vispy_get_fullscreen(self):
+        return False
+
+
+# ------------------------------------------------------------------- timer ---
+
+class TimerBackend(BaseTimerBackend):
+
+    def __init__(self, vispy_timer):
+        super().__init__(vispy_timer)
+        self._loop = asyncio.get_event_loop()
+        self._task = None
+
+    async def _timer_coro(self, interval):
+        while True:
+            await asyncio.sleep(interval)
+            self._vispy_timeout()
+
+    def _vispy_start(self, interval):
+        if self._task is not None:
+            self._task.cancel()
+        self._task = asyncio.create_task(self._timer_coro(interval))
+
+    def _vispy_stop(self):
+        self._task.cancel()
+        self._task = None
+
+    def _vispy_timeout(self):
+        self._loop.call_soon(self._vispy_timer._timeout)
+
+
+def _stop_timers(canvas):
+    """Stop all timers associated with a canvas."""
+    # This is nice and all, but the Canvas object is frozen, so this is never actually used
+    for attr in dir(canvas):
+        try:
+            attr_obj = getattr(canvas, attr)
+        except NotImplementedError:
+            continue  # prevent error due to props that we don't implement
+        else:
+            if isinstance(attr_obj, Timer):
+                attr_obj.stop()

vispy/app/backends/_offscreen_util.py

@@ -0,0 +1,121 @@
+"""
+Utils for offscreen rendering.
+"""
+
+from .. import Application, Canvas
+from ... import gloo
+
+
+class OffscreenContext:
+    """ A helper class to provide an OpenGL context. This context is global
+    to the application.
+    """
+
+    _global_instance = None
+    _canvas = None
+
+    @classmethod
+    def get_global_instance(cls):
+        """ Get a global context. Note that any assumptions about OpenGL state
+        being local will not hold.
+        """
+        if cls._global_instance is None:
+            cls._global_instance = cls()
+        return cls._global_instance
+
+    def __init__(self):
+        if self._canvas is not None:
+            return  # already initialized
+
+        self._is_closed = False
+
+        # Glfw is probably the most lightweight approach, so let's try that.
+        # But there are two incompatible packages providing glfw :/
+        self.glfw = None
+        try:
+            import glfw
+        except ImportError:
+            pass
+        else:
+            need_from_glfw = ["create_window", "make_context_current"]
+            if all(hasattr(glfw, attr) for attr in need_from_glfw):
+                self.glfw = glfw
+
+        if self.glfw:
+            self.glfw.init()
+            self.glfw.window_hint(self.glfw.VISIBLE, 0)
+            self._canvas = self.glfw.create_window(1, 1, "dummy window", None, None)
+        else:
+            try:
+                _app = Application('default')
+            except Exception:
+                raise RuntimeError(
+                    "Cannot find a backend to create an OpenGL context. "
+                    "Install e.g. PyQt5, PySide2, or `pip install glfw`."
+                )
+            self._canvas = Canvas(app=_app)
+            self._canvas.show(False)
+
+    def make_current(self):
+        """ Make this the currently active context.
+        """
+        # If an application only used off-screen canvases this would technically
+        # have to be called just once. But note that an application/session
+        # could run both real canvases and off-screen ones.
+        if self.glfw:
+            self.glfw.make_context_current(self._canvas)
+        else:
+            self._canvas.set_current()
+
+    def close(self):
+        """ Close the context. """
+        # Cannot close the global instance
+        if self is OffscreenContext._global_instance:
+            return
+        elif not self._is_closed:
+            self._is_closed = True
+            if self.glfw:
+                self.glfw.destroy_window(self._canvas)
+            else:
+                self._canvas.close()
+
+    def __del__(self):
+        self.close()
+
+
+class FrameBufferHelper:
+    """ Provides a canvas to render to, using an FBO.
+    """
+
+    def __init__(self):
+        self._fbo = None
+        self._physical_size = 1, 1
+        self._fbo_size = -1, -1
+
+    def _ensure_fbo(self):
+        if self._fbo_size != self._physical_size:
+            self._fbo_size = self._physical_size
+            w, h = self._fbo_size
+            if self._fbo is None:
+                color_buffer = gloo.Texture2D((h, w, 4))
+                depth_buffer = gloo.RenderBuffer((h, w))
+                self._fbo = gloo.FrameBuffer(color_buffer, depth_buffer)
+            else:
+                self._fbo.resize((h, w))
+
+    def set_physical_size(self, w, h):
+        """ Set the physical size of the canvas.
+        """
+        self._physical_size = w, h
+
+    def get_frame(self):
+        """ Call this within the with-context to obtain the frame buffer contents.
+        """
+        return self._fbo.read()
+
+    def __enter__(self):
+        self._ensure_fbo()
+        return self._fbo.__enter__()
+
+    def __exit__(self, *args):
+        return self._fbo.__exit__(*args)

vispy/app/backends/_osmesa.py

@@ -0,0 +1,235 @@
+# -*- coding: utf-8 -*-
+# vispy: testskip
+# Copyright (c) Vispy Development Team. All Rights Reserved.
+# Distributed under the (new) BSD License. See LICENSE.txt for more info.
+"""OSMesa backend for offscreen rendering on Linux/Unix."""
+from __future__ import division
+from ...util.ptime import time
+from ..base import (BaseApplicationBackend, BaseCanvasBackend,
+                    BaseTimerBackend)
+from ...gloo import gl
+from time import sleep
+
+try:
+    from ...ext import osmesa
+except Exception as exp:
+    available, testable, why_not, which = False, False, str(exp), None
+else:
+    available, testable, why_not, which = True, True, None, 'OSMesa'
+
+# -------------------------------------------------------------- capability ---
+capability = dict(
+    # if True they mean:
+    title=True,          # can set title on the fly
+    size=True,           # can set size on the fly
+    position=False,       # can set position on the fly
+    show=True,           # can show/hide window XXX ?
+    vsync=False,          # can set window to sync to blank
+    resizable=False,      # can toggle resizability (e.g., no user resizing)
+    decorate=True,       # can toggle decorations
+    fullscreen=False,     # fullscreen window support
+    context=True,        # can share contexts between windows
+    multi_window=True,   # can use multiple windows at once
+    scroll=False,         # scroll-wheel events are supported
+    parent=False,         # can pass native widget backend parent
+    always_on_top=False,  # can be made always-on-top
+)
+
+
+_VP_OSMESA_ALL_WINDOWS = []
+
+
+def _get_osmesa_windows():
+    return [win for win in _VP_OSMESA_ALL_WINDOWS
+            if isinstance(win, CanvasBackend)]
+
+
+# ------------------------------------------------------------- application ---
+class ApplicationBackend(BaseApplicationBackend):
+
+    def __init__(self):
+        BaseApplicationBackend.__init__(self)
+        self._timers = list()
+
+    def _add_timer(self, timer):
+        if timer not in self._timers:
+            self._timers.append(timer)
+
+    def _vispy_get_backend_name(self):
+        return 'osmesa'
+
+    def _vispy_process_events(self):
+        for timer in self._timers:
+            timer._tick()
+        wins = _get_osmesa_windows()
+        for win in wins:
+            if win._needs_draw:
+                win._needs_draw = False
+                win._on_draw()
+
+    def _vispy_run(self):
+        wins = _get_osmesa_windows()
+        while not all(w.closed for w in wins):
+            self._vispy_process_events()
+        self._vispy_quit()
+
+    def _vispy_quit(self):
+        wins = _get_osmesa_windows()
+        for win in wins:
+            win._vispy_close()
+        for timer in self._timers:
+            timer._vispy_stop()
+        self._timers = []
+
+    def _vispy_get_native_app(self):
+        return osmesa
+
+
+class OSMesaContext(object):
+    """
+    A wrapper around an OSMesa context that destroy the context when
+    garbage collected
+    """
+
+    def __init__(self):
+        self.context = osmesa.OSMesaCreateContext()
+
+    def make_current(self, pixels, width, height):
+        return osmesa.OSMesaMakeCurrent(self.context, pixels, width, height)
+
+    def __del__(self):
+        osmesa.OSMesaDestroyContext(self.context)
+
+
+# ------------------------------------------------------------------ canvas ---
+class CanvasBackend(BaseCanvasBackend):
+    """OSMesa backend for Canvas"""
+
+    def __init__(self, vispy_canvas, **kwargs):
+        BaseCanvasBackend.__init__(self, vispy_canvas)
+        # We use _process_backend_kwargs() to "serialize" the kwargs
+        # and to check whether they match this backend's capability
+        p = self._process_backend_kwargs(kwargs)
+
+        # Deal with config
+        # TODO: We do not support setting config
+        # ... use context.config
+        # Deal with context
+        p.context.shared.add_ref('osmesa', self)
+        if p.context.shared.ref is self:
+            self._native_context = OSMesaContext()
+        else:
+            self._native_context = p.context.shared.ref._native_context
+
+        self._closed = False
+        self._pixels = None
+        self._vispy_set_size(*p.size)
+        _VP_OSMESA_ALL_WINDOWS.append(self)
+
+        self._vispy_canvas.set_current()
+        self._vispy_canvas.events.initialize()
+
+    def _vispy_set_current(self):
+        if self._native_context is None:
+            raise RuntimeError('Native context is None')
+        if self._pixels is None:
+            raise RuntimeError('Pixel buffer has already been deleted')
+
+        ok = self._native_context.make_current(self._pixels, self._size[0],
+                                               self._size[1])
+        if not ok:
+            raise RuntimeError('Failed attaching OSMesa rendering buffer')
+
+    def _vispy_swap_buffers(self):
+        if self._pixels is None:
+            raise RuntimeError('No pixel buffer')
+        gl.glFinish()
+
+    def _vispy_set_title(self, title):
+        pass
+
+    def _vispy_set_size(self, w, h):
+        self._pixels = osmesa.allocate_pixels_buffer(w, h)
+        self._size = (w, h)
+        self._vispy_canvas.events.resize(size=(w, h))
+        self._vispy_set_current()
+        self._vispy_update()
+
+    def _vispy_set_position(self, x, y):
+        pass
+
+    def _vispy_set_visible(self, visible):
+        if visible:
+            self._vispy_set_current()
+            self._vispy_update()
+
+    def _vispy_set_fullscreen(self, fullscreen):
+        pass
+
+    def _vispy_update(self):
+        # This is checked by osmesa ApplicationBackend in process_events
+        self._needs_draw = True
+
+    def _vispy_close(self):
+        if self.closed:
+            return
+        # We do not set self._native_context = None here because this causes
+        # trouble in case a canvas is closed multiple times (as in
+        # app.test_run()). The problem occurs in gloo's glir._gl_initialize
+        # when it tries to call glGetString(GL_VERSION).
+        # But OSMesa requires a context to be attached when calling
+        # glGetString otherwise it returns an empty string, which gloo doesn't
+        # like
+        self._closed = True
+        return
+
+    def _vispy_warmup(self):
+        etime = time() + 0.1
+        while time() < etime:
+            sleep(0.01)
+            self._vispy_canvas.set_current()
+            self._vispy_canvas.app.process_events()
+
+    def _vispy_get_size(self):
+        if self._pixels is None:
+            return
+        return self._size
+
+    @property
+    def closed(self):
+        return self._closed
+
+    def _vispy_get_position(self):
+        return 0, 0
+
+    def _vispy_get_fullscreen(self):
+        return False
+
+    def _on_draw(self):
+        # This is called by the osmesa ApplicationBackend
+        if self._vispy_canvas is None or self._pixels is None:
+            raise RuntimeError('draw with no canvas or pixels attached')
+            return
+        self._vispy_set_current()
+        self._vispy_canvas.events.draw(region=None)  # (0, 0, w, h)
+
+
+# ------------------------------------------------------------------- timer ---
+class TimerBackend(BaseTimerBackend):
+
+    def __init__(self, vispy_timer):
+        BaseTimerBackend.__init__(self, vispy_timer)
+        vispy_timer._app._backend._add_timer(self)
+        self._vispy_stop()
+
+    def _vispy_start(self, interval):
+        self._interval = interval
+        self._next_time = time() + self._interval
+
+    def _vispy_stop(self):
+        self._next_time = float('inf')
+
+    def _tick(self):
+        if time() > self._next_time:
+            self._vispy_timer._timeout()
+            self._next_time = time() + self._interval