vispy 0.13.0__tar.gz → 0.14.0__tar.gz

vispy-0.14.0/.git_archival.txt

@@ -0,0 +1,4 @@
+node: $Format:%H$
+node-date: $Format:%cI$
+describe-name: $Format:%(describe:tags=true,match=*[0-9]*)$
+ref-names: $Format:%D$

{vispy-0.13.0 → vispy-0.14.0}/.github/workflows/main.yml

@@ -111,7 +111,7 @@ jobs:
         sleep 5
         # export python_version
         echo "python_version=310" >> $GITHUB_OUTPUT
-    - uses: mamba-org/provision-with-micromamba@v15
+    - uses: mamba-org/provision-with-micromamba@v16
       with:
         environment-file: ./ci/requirements/py${{ steps.vars.outputs.python_version }}.yml
     - name: Install conda-dependencies
@@ -225,7 +225,7 @@ jobs:
         # export python_version
         PY_VER=${{ matrix.python_version }}
         echo "python_version=${PY_VER//.}" >> $GITHUB_OUTPUT
-    - uses: mamba-org/provision-with-micromamba@v15
+    - uses: mamba-org/provision-with-micromamba@v16
       with:
         environment-file: ./ci/requirements/py${{ steps.vars.outputs.python_version }}.yml
     - name: Install conda-dependencies

{vispy-0.13.0 → vispy-0.14.0}/.github/workflows/wheels.yml

@@ -27,16 +27,18 @@ jobs:
       if: ${{ matrix.arch == 'aarch64' }}
       uses: docker/setup-qemu-action@v2
     - name: Build wheels
-      uses: pypa/cibuildwheel@v2.12.3
+      uses: pypa/cibuildwheel@v2.15.0
       env:
         CIBW_SKIP: "cp36-* pp* *-win32 *-manylinux_i686 *-musllinux*"
         CIBW_ARCHS_LINUX: ${{ matrix.arch }}
         CIBW_TEST_REQUIRES: "pytest pytest-sugar meshio pillow sphinx_gallery imageio"
         CIBW_TEST_COMMAND: "python -c \"import vispy; vispy.test('nobackend')\""
         CIBW_BUILD_VERBOSITY: "2"
-        CIBW_BEFORE_BUILD: "pip install -U numpy Cython"
-        CIBW_BEFORE_BUILD_MACOS: "pip install -U pip setuptools"
-        CIBW_BEFORE_BUILD_LINUX: "yum install -y fontconfig || apk add fontconfig-dev jpeg-dev; pip install -U pip setuptools; pip install freetype-py"
+        # Get numpy release candidate to have Python 3.12 compatibility (hopefully)
+        CIBW_BEFORE_BUILD: "pip install -U Cython pip setuptools; pip install -U --pre numpy"
+        CIBW_BEFORE_TEST: "pip install -U Cython pip setuptools; pip install -U --pre numpy"
+        #CIBW_BEFORE_BUILD_MACOS: "pip install -U pip setuptools"
+        CIBW_BEFORE_BUILD_LINUX: "yum install -y fontconfig || apk add fontconfig-dev jpeg-dev; pip install freetype-py"
         # If freetype-py is installed from source (no wheel found), include bundled freetype library
         CIBW_ENVIRONMENT_WINDOWS: "FREETYPEPY_BUNDLE_FT=1"
         CIBW_ENVIRONMENT: "GITHUB_ACTIONS=true"

{vispy-0.13.0 → vispy-0.14.0}/CHANGELOG.md

@@ -1,5 +1,30 @@
 # Release Notes
 
+## [v0.14.0](https://github.com/vispy/vispy/tree/v0.14.0) (2023-09-08)
+
+**Enhancements:**
+
+- Remove deprecated code from vispy.color.get\_colormap [\#2519](https://github.com/vispy/vispy/pull/2519) ([codypiersall](https://github.com/codypiersall))
+- Cache make\_pattern on DashAtlas [\#2508](https://github.com/vispy/vispy/pull/2508) ([aganders3](https://github.com/aganders3))
+- Add push/pop gl\_state for visuals \(used in picking\) [\#2502](https://github.com/vispy/vispy/pull/2502) ([aganders3](https://github.com/aganders3))
+- Add primitive picking filters for Mesh and Markers visuals [\#2500](https://github.com/vispy/vispy/pull/2500) ([aganders3](https://github.com/aganders3))
+
+**Fixed bugs:**
+
+- Fix spherical markers depth buffer with scaling='visual' [\#2506](https://github.com/vispy/vispy/pull/2506) ([brisvag](https://github.com/brisvag))
+- Update \_glfw.py [\#2496](https://github.com/vispy/vispy/pull/2496) ([smyeungx](https://github.com/smyeungx))
+- Fix mesh shading with flipped normals [\#2493](https://github.com/vispy/vispy/pull/2493) ([brisvag](https://github.com/brisvag))
+
+**Merged pull requests:**
+
+- Bump pypa/cibuildwheel from 2.14.1 to 2.15.0 and add Python 3.12 wheels [\#2515](https://github.com/vispy/vispy/pull/2515) ([dependabot[bot]](https://github.com/apps/dependabot))
+- Bump pypa/cibuildwheel from 2.14.0 to 2.14.1 [\#2509](https://github.com/vispy/vispy/pull/2509) ([dependabot[bot]](https://github.com/apps/dependabot))
+- Bump pypa/cibuildwheel from 2.13.1 to 2.14.0 [\#2507](https://github.com/vispy/vispy/pull/2507) ([dependabot[bot]](https://github.com/apps/dependabot))
+- Bump pypa/cibuildwheel from 2.13.0 to 2.13.1 [\#2498](https://github.com/vispy/vispy/pull/2498) ([dependabot[bot]](https://github.com/apps/dependabot))
+- Bump pypa/cibuildwheel from 2.12.3 to 2.13.0 [\#2492](https://github.com/vispy/vispy/pull/2492) ([dependabot[bot]](https://github.com/apps/dependabot))
+- Bump mamba-org/provision-with-micromamba from 15 to 16 [\#2490](https://github.com/vispy/vispy/pull/2490) ([dependabot[bot]](https://github.com/apps/dependabot))
+- Add lasso selection example [\#2485](https://github.com/vispy/vispy/pull/2485) ([DanAurea](https://github.com/DanAurea))
+
 ## [v0.13.0](https://github.com/vispy/vispy/tree/v0.13.0) (2023-05-12)
 
 **Enhancements:**

{vispy-0.13.0/vispy.egg-info → vispy-0.14.0}/PKG-INFO

@@ -1,12 +1,12 @@
 Metadata-Version: 2.1
 Name: vispy
-Version: 0.13.0
+Version: 0.14.0
 Summary: Interactive visualization in Python
 Home-page: http://vispy.org
 Download-URL: https://pypi.python.org/pypi/vispy
 Author: Vispy contributors
 Author-email: vispy@googlegroups.com
-License: (new) BSD
+License: BSD-3-Clause
 Keywords: visualization,OpenGl,ES,medical,imaging,3D,plotting,numpy,bigdata,ipython,jupyter,widgets
 Platform: any
 Classifier: Development Status :: 3 - Alpha
@@ -19,12 +19,13 @@ Classifier: Operating System :: MacOS :: MacOS X
 Classifier: Operating System :: Microsoft :: Windows
 Classifier: Operating System :: POSIX
 Classifier: Programming Language :: Python
-Classifier: Programming Language :: Python :: 3.6
-Classifier: Programming Language :: Python :: 3.7
 Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
 Classifier: Framework :: IPython
 Provides: vispy
-Requires-Python: >=3.6
+Requires-Python: >=3.8
 Description-Content-Type: text/x-rst
 Provides-Extra: ipython-static
 Provides-Extra: pyglet

{vispy-0.13.0 → vispy-0.14.0}/examples/demo/scene/picking.py

@@ -18,7 +18,7 @@ plt.xlabel.text = 'Time (ms)'
 selected = None
 
 # plot data
-cmap = get_colormap('hsl', value=0.5)
+cmap = get_colormap('hsl')
 colors = cmap.map(np.linspace(0.1, 0.9, data.shape[0]))
 t = np.arange(data.shape[1]) * (dt * 1000)
 for i, y in enumerate(data):

vispy-0.14.0/examples/scene/face_picking.py

@@ -0,0 +1,149 @@
+# -*- coding: utf-8 -*-
+# vispy: gallery 30
+# -----------------------------------------------------------------------------
+# Copyright (c) Vispy Development Team. All Rights Reserved.
+# Distributed under the (new) BSD License. See LICENSE.txt for more info.
+# -----------------------------------------------------------------------------
+"""
+Picking Faces from a Mesh
+=========================
+
+Demonstrates how to identify (pick) individual faces on a mesh.
+
+Arguments:
+* --mesh - Path to a mesh file (OBJ/OBJ.GZ) [optional]
+
+Controls:
+* p  - Toggle face picking view - shows the colors encoding face ID
+* r  - Clear painted faces
+* s  - Cycle shading modes (None, 'flat', 'smooth')
+* w  - Toggle wireframe
+"""
+import argparse
+import itertools
+import time
+
+import numpy as np
+
+from vispy import app, scene
+from vispy.io import read_mesh, load_data_file
+from vispy.scene.visuals import Mesh
+from vispy.scene import transforms
+from vispy.visuals.filters import ShadingFilter, WireframeFilter, FacePickingFilter
+
+
+parser = argparse.ArgumentParser()
+default_mesh = load_data_file('orig/triceratops.obj.gz')
+parser.add_argument('--mesh', default=default_mesh)
+args, _ = parser.parse_known_args()
+
+vertices, faces, _normals, _texcoords = read_mesh(args.mesh)
+
+canvas = scene.SceneCanvas(keys='interactive', bgcolor='white')
+view = canvas.central_widget.add_view()
+
+view.camera = 'arcball'
+view.camera.depth_value = 1e3
+
+# Create a colored `MeshVisual`.
+face_colors = np.tile((0.5, 0.0, 0.5, 1.0), (len(faces), 1))
+mesh = Mesh(
+    vertices,
+    faces,
+    face_colors=face_colors.copy()
+)
+mesh.transform = transforms.MatrixTransform()
+mesh.transform.rotate(90, (1, 0, 0))
+mesh.transform.rotate(-45, (0, 0, 1))
+view.add(mesh)
+
+# Use filters to affect the rendering of the mesh.
+wireframe_filter = WireframeFilter()
+shading_filter = ShadingFilter()
+face_picking_filter = FacePickingFilter()
+mesh.attach(wireframe_filter)
+mesh.attach(shading_filter)
+mesh.attach(face_picking_filter)
+
+
+def attach_headlight(view):
+    light_dir = (0, 1, 0, 0)
+    shading_filter.light_dir = light_dir[:3]
+    initial_light_dir = view.camera.transform.imap(light_dir)
+
+    @view.scene.transform.changed.connect
+    def on_transform_change(event):
+        transform = view.camera.transform
+        shading_filter.light_dir = transform.map(initial_light_dir)[:3]
+
+
+attach_headlight(view)
+
+shading = itertools.cycle(("flat", "smooth", None))
+shading_filter.shading = next(shading)
+
+
+throttle = time.monotonic()
+
+
+@canvas.events.mouse_move.connect
+def on_mouse_move(event):
+    global throttle
+    # throttle mouse events to 50ms
+    if time.monotonic() - throttle < 0.05:
+        return
+    throttle = time.monotonic()
+
+    # adjust the event position for hidpi screens
+    render_size = tuple(d * canvas.pixel_scale for d in canvas.size)
+    x_pos = event.pos[0] * canvas.pixel_scale
+    y_pos = render_size[1] - (event.pos[1] * canvas.pixel_scale)
+
+    # render a small patch around the mouse cursor
+    restore_state = not face_picking_filter.enabled
+    face_picking_filter.enabled = True
+    mesh.update_gl_state(blend=False)
+    picking_render = canvas.render(
+        region=(x_pos - 1, y_pos - 1, 3, 3),
+        size=(3, 3),
+        bgcolor=(0, 0, 0, 0),
+        alpha=True,
+    )
+    if restore_state:
+        face_picking_filter.enabled = False
+    mesh.update_gl_state(blend=not face_picking_filter.enabled)
+
+    # unpack the face index from the color in the center pixel
+    face_idx = (picking_render.view(np.uint32) - 1)[1, 1, 0]
+
+    if face_idx > 0 and face_idx < len(face_colors):
+        # this may be less safe, but it's faster than set_data
+        mesh.mesh_data._face_colors_indexed_by_faces[face_idx] = (0, 1, 0, 1)
+        mesh.mesh_data_changed()
+
+
+@canvas.events.key_press.connect
+def on_key_press(event):
+    if event.key == 'p':
+        face_picking_filter.enabled = not face_picking_filter.enabled
+        mesh.update_gl_state(blend=not face_picking_filter.enabled)
+        mesh.update()
+
+    if event.key == 'r':
+        mesh.set_data(vertices, faces, face_colors=face_colors)
+
+    if event.key == 's':
+        shading_filter.shading = next(shading)
+        mesh.update()
+
+    if event.key == 'w':
+        wireframe_filter.enabled = not wireframe_filter.enabled
+        mesh.update()
+
+
+canvas.show()
+
+
+if __name__ == "__main__":
+    print(__doc__)
+    app.run()

vispy-0.14.0/examples/scene/lasso.py

@@ -0,0 +1,158 @@
+# -*- coding: utf-8 -*-
+# vispy: gallery 30
+# -----------------------------------------------------------------------------
+# Copyright (c) Vispy Development Team. All Rights Reserved.
+# Distributed under the (new) BSD License. See LICENSE.txt for more info.
+# -----------------------------------------------------------------------------
+"""
+Vispy Lasso
+===========
+
+Demonstrate the use of lasso selection.
+
+The lasso selection is done on a 2D scatter but could be extended further by user.
+"""
+import sys
+import warnings
+import numpy as np
+from vispy import app, scene
+from vispy.geometry import curves
+from vispy.scene import visuals
+
+try:
+    from matplotlib import path
+except ImportError:
+    warnings.warn("Lasso example requires matplotlib for more accurate selection. Falling back to numpy based selection.")
+    path = None
+
+LASSO_COLOR               = (1, .1, .1)
+FILTERED_COLOR            = (1, 1, 1, 0.3)
+SELECTED_COLOR            = (0.3, 0, 1, 1.0)
+PEN_RADIUS                = 2
+MIN_MOVE_UPDATE_THRESHOLD = 5
+NUMBER_POINT              = 2000000
+SCATTER_SIZE              = 5
+
+canvas = scene.SceneCanvas(keys='interactive', show=True)
+view = canvas.central_widget.add_view()
+
+pointer = scene.visuals.Ellipse(center=(0., 0.), radius=(PEN_RADIUS, PEN_RADIUS,), color=None, border_width=0.2, border_color="white",
+                                num_segments=10, parent=view.scene)
+
+lasso = scene.visuals.Line(pos=np.array([[0, 0], [0, 0]]), color = LASSO_COLOR, parent=view.scene, width = PEN_RADIUS , antialias=True)
+px, py = 0, 0
+
+# generate data
+pos = 360 * np.random.normal(size=(NUMBER_POINT, 2), scale=1)
+
+# one could stop here for the data generation, the rest is just to make the
+# data look more interesting. Copied over from magnify.py
+centers = np.random.normal(size=(NUMBER_POINT, 2), scale = 1) * 960
+indexes = np.random.normal(size=NUMBER_POINT, loc=centers.shape[0] / 2,
+                           scale=centers.shape[0] / 3)
+indexes = np.clip(indexes, 0, centers.shape[0] - 1).astype(int)
+pos += centers[indexes]
+
+# create scatter object and fill in the data
+scatter = visuals.Markers()
+point_color = np.full((NUMBER_POINT, 4), FILTERED_COLOR)
+selected_mask = np.full(NUMBER_POINT, False)
+scatter.set_data(pos, edge_width=0, face_color=point_color, size=SCATTER_SIZE)
+
+view.add(scatter)
+
+def points_in_polygon(polygon, pts):
+    """Get boolean mask of points in a polygon reusing matplotlib implementation.
+    
+    The fallback code is based from StackOverflow answer by ``Ta946`` in this question:
+    https://stackoverflow.com/questions/36399381/whats-the-fastest-way-of-checking-if-a-point-is-inside-a-polygon-in-python
+
+    This is a proof of concept and depending on your use case, willingness
+    to add other dependencies, and your performance needs one of the other answers
+    on the above question would serve you better (ex. shapely, etc).
+    """
+    # Filter vertices out of the polygon's bounding box, this serve as an early optimization whenever number of vertices
+    # to filter out is huge.
+    x1, x2, y1, y2 = min(polygon[:, 0]), max(polygon[:, 0]), min(polygon[:, 1]), max(polygon[:, 1])
+    selection_mask = (x1 < pts[:, 0]) & (pts[:, 0] < x2) & (y1 < pts[:, 1]) & (pts[:, 1] < y2)
+    pts_in_bbox = pts[selection_mask]
+
+    # Select vertices inside the polygon.
+    if path is not None:
+        polygon = path.Path(polygon[:, :2], closed = True)
+        polygon_mask = polygon.contains_points(pts_in_bbox[:, :2]) 
+    else:
+        contour2 = np.vstack((polygon[1:], polygon[:1]))
+        test_diff = contour2-polygon
+        m1 = (polygon[:,1] > pts_in_bbox[:,None,1]) != (contour2[:,1] > pts_in_bbox[:,None,1])
+        slope = ((pts_in_bbox[:,None,0]-polygon[:,0])*test_diff[:,1])-(test_diff[:,0]*(pts_in_bbox[:,None,1]-polygon[:,1]))
+        m2 = slope == 0
+        mask2 = (m1 & m2).any(-1)
+        m3 = (slope < 0) != (contour2[:,1] < polygon[:,1])
+        m4 = m1 & m3
+        count = np.count_nonzero(m4, axis=-1)
+        mask3 = ~(count%2==0)
+        polygon_mask = mask2 | mask3
+
+    # Return the full selection mask based on bounding box & polygon selection.
+    selection_mask[np.where(selection_mask == True)] &= polygon_mask
+
+    return selection_mask
+
+def select(polygon_vertices, points):
+    # Set default mask to filter everything since user selection
+    # is not yet calculated.
+    selected_mask = np.full((NUMBER_POINT, 4), FILTERED_COLOR)
+
+    if polygon_vertices is not None:
+        # Optimization: It's faster to convert lasso selection straight to visual coordinates since there's generally less vertices
+        # this would speed up the processing depending on the scene.
+        polygon_vertices = scatter.get_transform('canvas', 'visual').map(polygon_vertices)
+        selected_mask = points_in_polygon(polygon_vertices, points)
+
+    return selected_mask
+
+@canvas.connect
+def on_mouse_press(event):
+    global point_color, selected_mask
+    
+    if event.button == 1:
+        # Reset lasso state.
+        lasso.set_data(pos=np.empty((1, 2)))
+        
+        # Reset selected vertices to the filtered color, this would earn some time in case
+        # scene contains a lot of vertices.
+        point_color[selected_mask] = FILTERED_COLOR
+
+        scatter.set_data(pos, edge_width=0, face_color=point_color, size=SCATTER_SIZE)
+        
+@canvas.connect
+def on_mouse_move(event):
+    global pointer, px, py
+
+    pp = event.pos
+
+    # Optimization: to avoid too much recalculation/update we can update scene only if the mouse
+    # moved a certain amount of pixel.
+    if (abs(px - pp[0]) > MIN_MOVE_UPDATE_THRESHOLD or abs(py - pp[1]) > MIN_MOVE_UPDATE_THRESHOLD):
+        pointer.center = pp
+        if event.button == 1:            
+            polygon_vertices = event.trail()
+            lasso.set_data(pos = np.insert(polygon_vertices, len(polygon_vertices), polygon_vertices[0], axis=0))
+            px, py = pp
+
+@canvas.connect
+def on_mouse_release(event):
+    global point_color, selected_mask
+
+    if event.button == 1:
+        selected_mask = select(event.trail(), pos)
+
+        # Set selected points with selection color
+        point_color[selected_mask] = SELECTED_COLOR
+        scatter.set_data(pos, edge_width=0, face_color=point_color, size=SCATTER_SIZE)
+
+if __name__ == '__main__':
+    canvas.show()
+    if sys.flags.interactive == 0:
+        app.run()

vispy-0.14.0/examples/scene/marker_picking.py

@@ -0,0 +1,155 @@
+# -*- coding: utf-8 -*-
+# vispy: gallery 30
+# -----------------------------------------------------------------------------
+# Copyright (c) Vispy Development Team. All Rights Reserved.
+# Distributed under the (new) BSD License. See LICENSE.txt for more info.
+# -----------------------------------------------------------------------------
+"""
+Picking Markers
+===============
+
+Demonstrates how to identify (pick) markers. Hover markers to change their
+symbol and color.
+
+Controls:
+* p  - Toggle picking view - shows the colors encoding marker ID
+* r  - Reset marker symbols and colors
+"""
+import random
+import time
+import numpy as np
+from scipy.constants import golden as GOLDEN
+
+from vispy import app, scene
+from vispy.scene.visuals import Markers
+from vispy.visuals.filters import MarkerPickingFilter
+
+canvas = scene.SceneCanvas(keys='interactive', bgcolor='black')
+view = canvas.central_widget.add_view(camera="panzoom")
+view.camera.rect = (-1, -1, 2, 2)
+
+# floret pattern
+n = 10_000
+radius = np.linspace(0, 0.9, n)**0.6  # prevent extreme density at center
+theta = np.arange(n) * GOLDEN
+pos = np.column_stack([radius * np.cos(theta), radius * np.sin(theta)])
+
+COLORS = [
+    (1, 0, 0, 1),  # red
+    (1, 0.5, 0, 1),  # orange
+    (1, 1, 0, 1),  # yellow
+    (0, 1, 0, 1),  # green
+    (0, 0, 1, 1),  # blue
+    (0.29, 0, 0.51, 1),  # indigo
+    (0.93, 0.51, 0.93, 1),  # violet
+]
+
+colors = np.zeros((n, 4), dtype=np.float32)
+colors[:, 0] = 1  # red
+colors[:, -1] = 1  # alpha
+_colors = colors.copy()
+
+symbols = list(Markers._symbol_shader_values.keys())
+symbols_ring = dict(zip(symbols, symbols[1:]))
+symbols_ring[symbols[-1]] = symbols[0]
+
+EDGE_COLOR = "white"
+MARKER_SIZE = 0.0125
+EDGE_WDITH = MARKER_SIZE / 10
+
+markers = Markers(
+    pos=pos,
+    edge_color=EDGE_COLOR,
+    face_color=colors,
+    size=MARKER_SIZE,
+    edge_width=EDGE_WDITH,
+    scaling="scene",
+)
+markers.update_gl_state(depth_test=True)
+view.add(markers)
+
+# Use filters to affect the rendering of the mesh.
+picking_filter = MarkerPickingFilter()
+markers.attach(picking_filter)
+
+
+@view.events.connect
+def on_viewbox_change(event):
+    # workaround for vispy/#2501
+    markers.update_gl_state(blend=not picking_filter.enabled)
+
+
+throttle = time.monotonic()
+
+
+@canvas.events.mouse_move.connect
+def on_mouse_move(event):
+    global throttle
+    # throttle mouse events to 50ms
+    if time.monotonic() - throttle < 0.05:
+        return
+    throttle = time.monotonic()
+
+    # adjust the event position for hidpi screens
+    render_size = tuple(d * canvas.pixel_scale for d in canvas.size)
+    x_pos = event.pos[0] * canvas.pixel_scale
+    y_pos = render_size[1] - (event.pos[1] * canvas.pixel_scale)
+
+    # render a small patch around the mouse cursor
+    restore_state = not picking_filter.enabled
+    picking_filter.enabled = True
+    markers.update_gl_state(blend=False)
+    picking_render = canvas.render(
+        crop=(x_pos - 2, y_pos - 2, 5, 5),
+        bgcolor=(0, 0, 0, 0),
+        alpha=True,
+    )
+    if restore_state:
+        picking_filter.enabled = False
+    markers.update_gl_state(blend=not picking_filter.enabled)
+
+    # unpack the face index from the color in the center pixel
+    marker_idx = (picking_render.view(np.uint32) - 1)[2, 2, 0]
+
+    if marker_idx >= 0 and marker_idx < len(pos):
+        new_symbols = list(markers.symbol)
+        new_symbol = symbols_ring[new_symbols[marker_idx]]
+        new_symbols[marker_idx] = new_symbol
+
+        colors[marker_idx] = random.choice(COLORS)
+        markers.set_data(
+            pos=pos,
+            edge_color=EDGE_COLOR,
+            face_color=colors,
+            size=MARKER_SIZE,
+            edge_width=EDGE_WDITH,
+            symbol=new_symbols,
+        )
+
+
+@canvas.events.key_press.connect
+def on_key_press(event):
+    global colors
+    if event.key == 'p':
+        # toggle face picking view
+        picking_filter.enabled = not picking_filter.enabled
+        markers.update_gl_state(blend=not picking_filter.enabled)
+        markers.update()
+    if event.key == 'r':
+        # reset marker symbols
+        colors = _colors.copy()
+        markers.set_data(
+            pos=pos,
+            edge_color=EDGE_COLOR,
+            face_color=colors,
+            size=MARKER_SIZE,
+            edge_width=EDGE_WDITH,
+        )
+
+
+canvas.show()
+
+
+if __name__ == "__main__":
+    print(__doc__)
+    app.run()

vispy-0.14.0/pyproject.toml

@@ -0,0 +1,13 @@
+[build-system]
+requires = [
+    "wheel",
+    'numpy; python_full_version<"3.12.0rc1"',
+    'numpy>=1.26.0rc1; python_full_version>="3.12.0rc1"',
+    "setuptools>=42",
+    "setuptools_scm[toml]>=7.1",
+    "Cython>=3.0.0"
+]
+
+[tools.setuptools_scm]
+write_to = "vispy/version.py"
+local_scheme = "dirty-tag"

{vispy-0.13.0 → vispy-0.14.0}/setup.py

@@ -24,15 +24,11 @@ Announcing:
 
 import os
 from os import path as op
-from distutils import log
-from setuptools import setup, find_packages, Extension
+from setuptools import setup, find_packages
 
 import numpy as np
 from Cython.Build import cythonize
-
-log.set_verbosity(log.DEBUG)
-log.info('setup.py entered')
-log.info('$PATH=%s' % os.environ['PATH'])
+from Cython.Distutils import Extension
 
 name = 'vispy'
 description = 'Interactive visualization in Python'
@@ -56,8 +52,11 @@ def set_builtin(name, value):
 
 
 extensions = [Extension('vispy.visuals.text._sdf_cpu',
-                        [op.join('vispy', 'visuals', 'text', '_sdf_cpu.pyx')],
-                        include_dirs=[np.get_include()]),
+                        sources=[op.join('vispy', 'visuals', 'text', '_sdf_cpu.pyx')],
+                        include_dirs=[np.get_include()],
+                        cython_directives={"language_level": "3"},
+                        define_macros=[("NPY_NO_DEPRECATED_API", "NPY_1_7_API_VERSION")],
+                        ),
               ]
 
 readme = open('README.rst', 'r').read()
@@ -70,7 +69,7 @@ setup(
     },
     author='Vispy contributors',
     author_email='vispy@googlegroups.com',
-    license='(new) BSD',
+    license='BSD-3-Clause',
     url='http://vispy.org',
     download_url='https://pypi.python.org/pypi/vispy',
     keywords=[
@@ -92,9 +91,8 @@ setup(
     long_description_content_type='text/x-rst',
     platforms='any',
     provides=['vispy'],
-    python_requires='>=3.6',
+    python_requires='>=3.8',
     install_requires=['numpy', 'freetype-py', 'hsluv', 'kiwisolver', 'packaging'],
-    setup_requires=['numpy', 'cython', 'setuptools_scm', 'setuptools_scm_git_archive', 'packaging'],
     extras_require={
         'ipython-static': ['ipython'],
         'pyglet': ['pyglet>=1.2'],
@@ -147,9 +145,10 @@ setup(
         'Operating System :: Microsoft :: Windows',
         'Operating System :: POSIX',
         'Programming Language :: Python',
-        'Programming Language :: Python :: 3.6',
-        'Programming Language :: Python :: 3.7',
         'Programming Language :: Python :: 3.8',
+        'Programming Language :: Python :: 3.9',
+        'Programming Language :: Python :: 3.10',
+        'Programming Language :: Python :: 3.11',
         'Framework :: IPython'
     ],
 )

{vispy-0.13.0 → vispy-0.14.0}/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))