vispy 0.14.0__cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl

vispy/util/fonts/_win32.py

@@ -0,0 +1,105 @@
+# -*- coding: utf-8 -*-
+# -----------------------------------------------------------------------------
+# Copyright (c) Vispy Development Team. All Rights Reserved.
+# Distributed under the (new) BSD License. See LICENSE.txt for more info.
+# -----------------------------------------------------------------------------
+
+import os
+from os import path as op
+import warnings
+
+
+from ctypes import (cast, byref, sizeof, create_unicode_buffer,
+                    c_void_p, c_wchar_p)
+from ...ext.gdi32plus import (gdiplus, gdi32, user32, winreg, LOGFONT,
+                              OUTLINETEXTMETRIC, GM_ADVANCED, FW_NORMAL,
+                              FW_BOLD, LF_FACESIZE, DEFAULT_CHARSET,
+                              TRUETYPE_FONTTYPE, FONTENUMPROC, BOOL)
+
+
+# Inspired by:
+# http://forums.codeguru.com/showthread.php?90792-How-to-get-a-system-
+# font-file-name-given-a-LOGFONT-face-name
+
+# XXX This isn't perfect, but it should work for now...
+
+def find_font(face, bold, italic, orig_face=None):
+    style_dict = {'Regular': 0, 'Bold': 1, 'Italic': 2, 'Bold Italic': 3}
+
+    # Figure out which font to actually use by trying to instantiate by name
+    dc = user32.GetDC(0)  # noqa, analysis:ignore
+    gdi32.SetGraphicsMode(dc, GM_ADVANCED)  # only TT and OT fonts
+    logfont = LOGFONT()
+    logfont.lfHeight = -12  # conv point to pixels
+    logfont.lfWeight = FW_BOLD if bold else FW_NORMAL
+    logfont.lfItalic = italic
+    logfont.lfFaceName = face  # logfont needs Unicode
+    hfont = gdi32.CreateFontIndirectW(byref(logfont))
+    original = gdi32.SelectObject(dc, hfont)
+    n_byte = gdi32.GetOutlineTextMetricsW(dc, 0, None)
+    assert n_byte > 0
+    metrics = OUTLINETEXTMETRIC()
+    assert sizeof(metrics) >= n_byte
+    assert gdi32.GetOutlineTextMetricsW(dc, n_byte, byref(metrics))
+    gdi32.SelectObject(dc, original)
+    user32.ReleaseDC(None, dc)
+    use_face = cast(byref(metrics, metrics.otmpFamilyName), c_wchar_p).value
+    if use_face != face:
+        warnings.warn('Could not find face match "%s", falling back to "%s"'
+                      % (orig_face or face, use_face))
+    use_style = cast(byref(metrics, metrics.otmpStyleName), c_wchar_p).value
+    use_style = style_dict.get(use_style, 'Regular')
+    # AK: I get "Standaard" for use_style, which is Dutch for standard/regular
+
+    # Now we match by creating private font collections until we find
+    # the one that was used
+    font_dir = op.join(os.environ['WINDIR'], 'Fonts')
+    reg = winreg.ConnectRegistry(None, winreg.HKEY_LOCAL_MACHINE)
+    key = 'SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\Fonts'
+    reg_vals = winreg.OpenKey(reg, key)
+    n_values = winreg.QueryInfoKey(reg_vals)[1]
+    fname = None
+    for vi in range(n_values):
+        name, ff = winreg.EnumValue(reg_vals, vi)[:2]
+        if name.endswith('(TrueType)'):
+            ff = op.join(font_dir, ff) if op.basename(ff) == ff else ff
+            assert op.isfile(ff)
+            pc = c_void_p()
+            assert gdiplus.GdipNewPrivateFontCollection(byref(pc)) == 0
+            gdiplus.GdipPrivateAddFontFile(pc, ff)
+            family = c_void_p()
+            if gdiplus.GdipCreateFontFamilyFromName(use_face, pc,
+                                                    byref(family)) == 0:
+                val = BOOL()
+                assert gdiplus.GdipIsStyleAvailable(family, use_style,
+                                                    byref(val)) == 0
+                if val.value:
+                    buf = create_unicode_buffer(LF_FACESIZE)
+                    assert gdiplus.GdipGetFamilyName(family, buf, 0) == 0
+                    assert buf.value == use_face
+                    fname = ff
+                    break
+    fname = fname or find_font('', bold, italic, face)  # fall back to default
+    return fname
+
+
+def _list_fonts():
+    dc = user32.GetDC(0)
+    gdi32.SetGraphicsMode(dc, GM_ADVANCED)  # only TT and OT fonts
+    logfont = LOGFONT()
+    logfont.lfCharSet = DEFAULT_CHARSET
+    logfont.lfFaceName = ''
+    logfont.lfPitchandFamily = 0
+    fonts = list()
+
+    def enum_fun(lp_logfont, lp_text_metric, font_type, l_param):
+        # Only support TTF for now (silly Windows shortcomings)
+        if font_type == TRUETYPE_FONTTYPE:
+            font = lp_logfont.contents.lfFaceName
+            if not font.startswith('@') and font not in fonts:
+                fonts.append(font)
+        return 1
+
+    gdi32.EnumFontFamiliesExW(dc, byref(logfont), FONTENUMPROC(enum_fun), 0, 0)
+    user32.ReleaseDC(None, dc)
+    return fonts

vispy/util/fonts/tests/test_font.py

@@ -0,0 +1,45 @@
+# -*- 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 warnings
+
+from vispy.testing import assert_in, run_tests_if_main
+from vispy.util.fonts import list_fonts, _load_glyph, _vispy_fonts
+import pytest
+
+known_bad_fonts = set([
+    'Noto Color Emoji',  # https://github.com/vispy/vispy/issues/1771
+    'Bahnschrift',  # https://github.com/vispy/vispy/pull/1974
+])
+
+# try both a vispy and system font   <--- what does this mean???
+sys_fonts = set(list_fonts()) - set(_vispy_fonts)
+
+
+def test_font_list():
+    """Test font listing"""
+    f = list_fonts()
+    assert len(f) > 0
+    for font in _vispy_fonts:
+        assert_in(font, f)
+
+
+@pytest.mark.parametrize('face', ['OpenSans'] + sorted(sys_fonts))
+def test_font_glyph(face):
+    """Test loading glyphs"""
+    if face in known_bad_fonts or face.split(" ")[0] in known_bad_fonts:
+        pytest.xfail()
+    font_dict = dict(face=face, size=12, bold=False, italic=False)
+    glyphs_dict = dict()
+    chars = 'foobar^C&#'
+    for char in chars:
+        # Warning that Arial might not exist
+        with warnings.catch_warnings(record=True):
+            warnings.simplefilter('always')
+            _load_glyph(font_dict, char, glyphs_dict)
+    assert len(glyphs_dict) == np.unique([c for c in chars]).size
+
+
+run_tests_if_main()

vispy/util/fourier.py

@@ -0,0 +1,69 @@
+# -*- 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
+
+
+def stft(x, n_fft=1024, step=512, fs=2*np.pi, window='hann'):
+    """Compute the STFT
+
+    Parameters
+    ----------
+    x : array-like
+        1D signal to operate on. ``If len(x) < n_fft``, x will be zero-padded
+        to length ``n_fft``.
+    n_fft : int
+        Number of FFT points. Much faster for powers of two.
+    step : int | None
+        Step size between calculations. If None, ``n_fft // 2``
+        will be used.
+    fs : float
+        The sample rate of the data.
+    window : str | None
+        Window function to use. Can be ``'hann'`` for Hann window, or None
+        for no windowing.
+
+    Returns
+    -------
+    stft : ndarray
+        Spectrogram of the data, shape (n_freqs, n_steps).
+
+    See also
+    --------
+    fft_freqs
+    """
+    x = np.asarray(x, float)
+    if x.ndim != 1:
+        raise ValueError('x must be 1D')
+    if window is not None:
+        if window not in ('hann',):
+            raise ValueError('window must be "hann" or None')
+        w = np.hanning(n_fft)
+    else:
+        w = np.ones(n_fft)
+    n_fft = int(n_fft)
+    step = max(n_fft // 2, 1) if step is None else int(step)
+    fs = float(fs)
+    zero_pad = n_fft - len(x)
+    if zero_pad > 0:
+        x = np.concatenate((x, np.zeros(zero_pad, float)))
+    n_freqs = n_fft // 2 + 1
+    n_estimates = (len(x) - n_fft) // step + 1
+    result = np.empty((n_freqs, n_estimates), np.complex128)
+    for ii in range(n_estimates):
+        result[:, ii] = np.fft.rfft(w * x[ii * step:ii * step + n_fft]) / n_fft
+    return result
+
+
+def fft_freqs(n_fft, fs):
+    """Return frequencies for DFT
+
+    Parameters
+    ----------
+    n_fft : int
+        Number of points in the FFT.
+    fs : float
+        The sampling rate.
+    """
+    return np.arange(0, (n_fft // 2 + 1)) / float(n_fft) * float(fs)

vispy/util/frozen.py

@@ -0,0 +1,25 @@
+# -*- coding: utf-8 -*-
+# Copyright (c) Vispy Development Team. All Rights Reserved.
+# Distributed under the (new) BSD License. See LICENSE.txt for more info.
+
+
+# Class adapted from:
+# http://stackoverflow.com/questions/3603502/
+
+class Frozen(object):
+    __isfrozen = False
+
+    def __setattr__(self, key, value):
+        if self.__isfrozen and not hasattr(self, key):
+            raise AttributeError('%r is not an attribute of class %s. Call '
+                                 '"unfreeze()" to allow addition of new '
+                                 'attributes' % (key, self))
+        object.__setattr__(self, key, value)
+
+    def freeze(self):
+        """Freeze the object so that only existing properties can be set"""
+        self.__isfrozen = True
+
+    def unfreeze(self):
+        """Unfreeze the object so that additional properties can be added"""
+        self.__isfrozen = False

vispy/util/gallery_scraper.py

@@ -0,0 +1,268 @@
+# -*- coding: utf-8 -*-
+# Copyright (c) Vispy Development Team. All Rights Reserved.
+# Distributed under the (new) BSD License. See LICENSE.txt for more info.
+"""Scraper for sphinx-gallery.
+
+This is used to collect screenshots from the examples when executed via
+sphinx-gallery. This can be included in any project wanting to take
+advantage of this by adding the following to your sphinx ``conf.py``:
+
+.. code-block:: python
+
+    sphinx_gallery_conf = {
+        ...
+        'image_scrapers': ('vispy',)
+    }
+
+The scraper is provided to sphinx-gallery via the
+``vispy._get_sg_image_scraper()`` function.
+
+"""
+
+from __future__ import annotations
+
+import os
+import time
+import shutil
+from vispy.io import imsave
+from vispy.gloo.util import _screenshot
+from vispy.scene import SceneCanvas
+
+from sphinx_gallery.scrapers import optipng, figure_rst
+
+
+class VisPyGalleryScraper:
+    """Custom sphinx-gallery scraper to save the current Canvas to an image."""
+
+    def __repr__(self):
+        return self.__class__.__name__
+
+    def __call__(self, block, block_vars, gallery_conf):
+        """Scrape VisPy Canvases and applications.
+
+        Parameters
+        ----------
+        block : tuple
+            A tuple containing the (label, content, line_number) of the block.
+        block_vars : dict
+            Dict of block variables.
+        gallery_conf : dict
+            Contains the configuration of Sphinx-Gallery
+
+        Returns
+        -------
+        rst : str
+            The ReSTructuredText that will be rendered to HTML containing
+            the images. This is often produced by
+            :func:`sphinx_gallery.scrapers.figure_rst`.
+
+        """
+        example_fn = block_vars["src_file"]
+        frame_num_list = self._get_frame_list_from_source(example_fn)
+        image_path_iterator = block_vars['image_path_iterator']
+        canvas_or_widget = get_canvaslike_from_globals(block_vars["example_globals"])
+        if not frame_num_list:
+            image_paths = []
+        elif isinstance(frame_num_list[0], str):
+            # example produces an image/animation as output
+            image_paths = []
+            for frame_image, image_path in zip(frame_num_list, image_path_iterator):
+                image_path = os.path.splitext(image_path)[0] + os.path.splitext(frame_image)[1]
+                shutil.move(frame_image, image_path)
+                image_paths.append(image_path)
+        else:
+            image_paths = self._save_example_to_files(
+                canvas_or_widget, frame_num_list, gallery_conf, image_path_iterator)
+
+        fig_titles = ""  # alt text
+        # FUTURE: Handle non-images (ex. MP4s) with raw HTML
+        return figure_rst(image_paths, gallery_conf['src_dir'], fig_titles)
+
+    def _save_example_to_files(self, canvas_or_widget, frame_num_list, gallery_conf, image_path_iterator):
+        image_path = next(image_path_iterator)
+        frame_grabber = FrameGrabber(canvas_or_widget, frame_num_list)
+        frame_grabber.collect_frames()
+        if len(frame_num_list) > 1:
+            # let's make an animation
+            # FUTURE: mp4 with imageio?
+            image_path = os.path.splitext(image_path)[0] + ".gif"
+            frame_grabber.save_animation(image_path)
+        else:
+            frame_grabber.save_frame(image_path)
+        frame_grabber.cleanup()
+        if 'images' in gallery_conf['compress_images']:
+            optipng(image_path, gallery_conf['compress_images_args'])
+        return [image_path]
+
+    def _get_frame_list_from_source(self, filename):
+        lines = open(filename, 'rb').read().decode('utf-8').splitlines()
+        for line in lines[:10]:
+            if not line.startswith("# vispy:"):
+                continue
+            if "gallery-exports" in line:
+                _frames = line.split('gallery-exports')[1].split(',')[0].strip()
+                frames = self._frame_exports_to_list(_frames)
+                break
+            if "gallery " in line:
+                # Get what frames to grab
+                _frames = line.split('gallery')[1].split(',')[0].strip()
+                frames = self._frame_specifier_to_list(_frames)
+                break
+        else:
+            # no frame number hint - don't grab any frames
+            frames = []
+        return frames
+
+    def _frame_specifier_to_list(self, frame_specifier):
+        _frames = frame_specifier or '0'
+        frames = [int(i) for i in _frames.split(':')]
+        if not frames:
+            frames = [5]
+        if len(frames) > 1:
+            frames = list(range(*frames))
+        return frames
+
+    def _frame_exports_to_list(self, frame_specifier):
+        frames = frame_specifier.split(" ")
+        frame_paths = []
+        for frame_fn in frames:
+            # existing image file created by the example
+            if not os.path.isfile(frame_fn):
+                raise FileNotFoundError(
+                    "Example gallery frame specifier must be a frame number, "
+                    "frame range, or relative filename produced by the example.")
+            frame_paths.append(frame_fn)
+        return frame_paths
+
+
+def get_canvaslike_from_globals(globals_dict):
+    qt_widget = _get_qt_top_parent(globals_dict)
+    if qt_widget is not None:
+        return qt_widget
+
+    # Get canvas
+    if "canvas" in globals_dict:
+        return globals_dict["canvas"]
+    if "Canvas" in globals_dict:
+        return globals_dict["Canvas"]()
+    if "fig" in globals_dict:
+        return globals_dict["fig"]
+    return None
+
+
+def _get_qt_top_parent(globals_dict):
+    if "QWidget" not in globals_dict and "QMainWindow" not in globals_dict and "QtWidgets" not in globals_dict:
+        return None
+
+    qtwidgets = globals_dict.get("QtWidgets")
+    qmainwindow = globals_dict.get("QMainWindow", getattr(qtwidgets, "QMainWindow", None))
+    qwidget = globals_dict.get("QWidget", getattr(qtwidgets, "QWidget", qmainwindow))
+    all_qt_widgets = [widget for widget in globals_dict.values()
+                      if isinstance(widget, qwidget) and widget is not None]
+    all_qt_mains = [widget for widget in all_qt_widgets if isinstance(widget, qmainwindow)]
+    if all_qt_mains:
+        return all_qt_mains[0]
+    if all_qt_widgets:
+        return all_qt_widgets[0]
+    return None
+
+
+class FrameGrabber:
+    """Helper to grab a series of screenshots from the current Canvas-like object."""
+
+    def __init__(self, canvas_obj, frame_grab_list: list[int]):
+        self._canvas = canvas_obj
+        self._done = False
+        self._current_frame = -1
+        self._collected_images = []
+        self._frames_to_grab = frame_grab_list[:]  # copy so original list is preserved
+
+    def cleanup(self):
+        from PyQt5.QtWidgets import QApplication
+        for child_widget in QApplication.allWidgets():
+            if hasattr(child_widget, 'close'):
+                child_widget.close()
+        QApplication.processEvents()
+
+    def on_draw(self, _):
+        if self._done:
+            return  # Grab only once
+        self._current_frame += 1
+        if self._current_frame in self._frames_to_grab:
+            self._frames_to_grab.remove(self._current_frame)
+            if isinstance(self._canvas, SceneCanvas):
+                im = self._canvas.render(alpha=True)
+            else:
+                im = _screenshot()
+            self._collected_images.append(im)
+        if not self._frames_to_grab or self._current_frame > self._frames_to_grab[0]:
+            self._done = True
+
+    def collect_frames(self):
+        """Show current Canvas and render and collect all frames requested."""
+        if self._is_qt_widget():
+            self._grab_qt_screenshot()
+        else:
+            self._grab_vispy_screenshots()
+
+    def _is_qt_widget(self):
+        try:
+            from PyQt5.QtWidgets import QWidget
+        except ImportError:
+            return False
+        return isinstance(self._canvas, QWidget)
+
+    def _grab_qt_screenshot(self):
+        from PyQt5.QtWidgets import QApplication
+        from PyQt5.QtCore import QTimer
+        self._canvas.show()
+        # Qt is going to grab from the screen so we need the window on top
+        self._canvas.raise_()
+        # We need to give the GUI event loop and OS time to draw everything
+        time.sleep(1.5)
+        QApplication.processEvents()
+        QTimer.singleShot(1000, self._grab_widget_screenshot)
+        time.sleep(1.5)
+        QApplication.processEvents()
+
+    def _grab_widget_screenshot(self):
+        from PyQt5.QtWidgets import QApplication
+        screen = QApplication.screenAt(self._canvas.pos())
+        screenshot = screen.grabWindow(int(self._canvas.windowHandle().winId()))
+        arr = self._qpixmap_to_ndarray(screenshot)
+        self._collected_images.append(arr)
+
+    @staticmethod
+    def _qpixmap_to_ndarray(pixmap):
+        from PyQt5 import QtGui
+        import numpy as np
+        im = pixmap.toImage().convertToFormat(QtGui.QImage.Format.Format_RGB32)
+        size = pixmap.size()
+        width = size.width()
+        height = size.height()
+        im_bits = im.constBits()
+        im_bits.setsize(height * width * 4)
+        # Convert 0xffRRGGBB buffer -> (B, G, R, 0xff) -> (R, G, B)
+        return np.array(im_bits).reshape((height, width, 4))[:, :, 2::-1]
+
+    def _grab_vispy_screenshots(self):
+        os.environ['VISPY_IGNORE_OLD_VERSION'] = 'true'
+        self._canvas.events.draw.connect(self.on_draw, position='last')
+        with self._canvas as c:
+            self._collect_frames(c)
+
+    def _collect_frames(self, canvas, limit=10000):
+        n = 0
+        while not self._done and n < limit:
+            canvas.update()
+            canvas.app.process_events()
+            n += 1
+        if n >= limit or len(self._frames_to_grab) > 0:
+            raise RuntimeError("Could not collect any images")
+
+    def save_frame(self, filename, frame_index=0):
+        imsave(filename, self._collected_images[frame_index])
+
+    def save_animation(self, filename):
+        import imageio  # multiple gif not properly supported yet
+        imageio.mimsave(filename, self._collected_images)

vispy/util/keys.py

@@ -0,0 +1,91 @@
+# -*- coding: utf-8 -*-
+# Copyright (c) Vispy Development Team. All Rights Reserved.
+# Distributed under the (new) BSD License. See LICENSE.txt for more info.
+
+"""Define constants for keys.
+
+Each key constant is defined as a Key object, which allows comparison with
+strings (e.g. 'A', 'Escape', 'Shift'). This enables handling of key events
+without using the key constants explicitly (e.g. ``if ev.key == 'Left':``).
+
+In addition, key objects that represent characters can be matched to
+the integer ordinal (e.g. 32 for space, 65 for A). This behavior is mainly
+intended as a compatibility measure.
+
+"""
+
+
+class Key(object):
+    """Represent the identity of a certain key.
+
+    This represents one or more names that the key in question is known by.
+
+    A Key object can be compared to one of its string names (case
+    insensitive), to the integer ordinal of the key (only for keys that
+    represent characters), and to another Key instance.
+    """
+
+    def __init__(self, *names):
+        self._names = names
+        self._names_upper = tuple([v.upper() for v in names])
+
+    @property
+    def name(self):
+        """The primary name of the key."""
+        return self._names[0]
+
+    def __hash__(self):
+        return self._names[0].__hash__()
+
+    def __repr__(self):
+        return "<Key %s>" % ', '.join([repr(v) for v in self._names])
+
+    def __eq__(self, other):
+        if isinstance(other, str):
+            return other.upper() in self._names_upper
+        elif isinstance(other, Key):
+            return self._names[0] == other
+        elif isinstance(other, int):
+            return other in [ord(v) for v in self._names_upper if len(v) == 1]
+        elif other is None:
+            return False
+        else:
+            raise ValueError('Key can only be compared to str, int and Key.')
+
+
+SHIFT = Key('Shift')
+CONTROL = Key('Control')
+ALT = Key('Alt')
+META = Key('Meta')  # That Mac thingy
+
+UP = Key('Up')
+DOWN = Key('Down')
+LEFT = Key('Left')
+RIGHT = Key('Right')
+PAGEUP = Key('PageUp')
+PAGEDOWN = Key('PageDown')
+
+INSERT = Key('Insert')
+DELETE = Key('Delete')
+HOME = Key('Home')
+END = Key('End')
+
+ESCAPE = Key('Escape')
+BACKSPACE = Key('Backspace')
+
+F1 = Key('F1')
+F2 = Key('F2')
+F3 = Key('F3')
+F4 = Key('F4')
+F5 = Key('F5')
+F6 = Key('F6')
+F7 = Key('F7')
+F8 = Key('F8')
+F9 = Key('F9')
+F10 = Key('F10')
+F11 = Key('F11')
+F12 = Key('F12')
+
+SPACE = Key('Space', ' ')
+ENTER = Key('Enter', 'Return', '\n')
+TAB = Key('Tab', '\t')