vispy 0.12.2__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.12.2 → 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.12.2 → vispy-0.14.0}/.github/workflows/wheels.yml

@@ -27,21 +27,25 @@ jobs:
       if: ${{ matrix.arch == 'aarch64' }}
       uses: docker/setup-qemu-action@v2
     - name: Build wheels
-      uses: pypa/cibuildwheel@v2.12.1
+      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"
         CIBW_MANYLINUX_X86_64_IMAGE: manylinux2014
         CIBW_MANYLINUX_I686_IMAGE: manylinux2014
+        CIBW_ARCHS_MACOS: 'x86_64 arm64'
+        CIBW_TEST_SKIP: '*-macosx_arm64'
     - uses: actions/upload-artifact@v3
       with:
         path: ./wheelhouse/*.whl

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

@@ -1,5 +1,49 @@
 # 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:**
+
+- Switch MarkersVisual scaling option to string "fixed", "scene", or "visual" [\#2470](https://github.com/vispy/vispy/pull/2470) ([djhoese](https://github.com/djhoese))
+- Add early-termination optimization to attenuated mip [\#2465](https://github.com/vispy/vispy/pull/2465) ([aganders3](https://github.com/aganders3))
+- Add `InstancedMeshVisual` for faster and easier rendering of repeated meshes [\#2461](https://github.com/vispy/vispy/pull/2461) ([brisvag](https://github.com/brisvag))
+- Instanced mesh example [\#2460](https://github.com/vispy/vispy/pull/2460) ([brisvag](https://github.com/brisvag))
+- Use QNativeEventGesture for touchpad gesture input [\#2456](https://github.com/vispy/vispy/pull/2456) ([aganders3](https://github.com/aganders3))
+
+**Fixed bugs:**
+
+- Fix TypeError with pinch-to-zoom [\#2483](https://github.com/vispy/vispy/pull/2483) ([aganders3](https://github.com/aganders3))
+
+**Merged pull requests:**
+
+- Bump pypa/cibuildwheel from 2.12.1 to 2.12.3 [\#2472](https://github.com/vispy/vispy/pull/2472) ([dependabot[bot]](https://github.com/apps/dependabot))
+- Cleanup site navbar with pydata-sphinx-theme 0.10+ [\#2371](https://github.com/vispy/vispy/pull/2371) ([djhoese](https://github.com/djhoese))
+
 ## [v0.12.2](https://github.com/vispy/vispy/tree/v0.12.2) (2023-03-20)
 
 **Enhancements:**

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

@@ -1,12 +1,12 @@
 Metadata-Version: 2.1
 Name: vispy
-Version: 0.12.2
+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.12.2 → vispy-0.14.0}/doc/conf.py

@@ -186,6 +186,7 @@ html_theme_options = {
     "use_edit_page_button": True,
     "github_url": "https://github.com/vispy/vispy",
     "twitter_url": "https://twitter.com/vispyproject",
+    "header_links_before_dropdown": 7,
 }
 
 # Add any paths that contain custom themes here, relative to this directory.
@@ -346,11 +347,11 @@ numpydoc_show_class_members = False
 # -----------------------------------------------------------------------------
 # intersphinx
 # -----------------------------------------------------------------------------
-_python_doc_base = 'https://docs.python.org/3.9'
+_python_doc_base = "https://docs.python.org/3"
 intersphinx_mapping = {
-    _python_doc_base: None,
-    'https://numpy.org/doc/stable/': None,
-    'https://scipy.github.io/devdocs/': None,
+    "python": (_python_doc_base, None),
+    "numpy": ("https://numpy.org/doc/stable/", None),
+    "scipy": ("https://scipy.github.io/devdocs/", None),
 }
 
 

{vispy-0.12.2 → vispy-0.14.0}/examples/basics/visuals/markers.py

@@ -4,7 +4,13 @@
 # Copyright (c) Vispy Development Team. All Rights Reserved.
 # Distributed under the (new) BSD License. See LICENSE.txt for more info.
 # -----------------------------------------------------------------------------
-""" Display markers at different sizes and line thicknessess.
+"""Display markers at different sizes and line thicknesses.
+
+Keyboard options:
+* spacebar: Cycle through possible marker symbols.
+* "s": Switch between "fixed" marker scaling (initial setting) and "scene"
+  scaling.
+
 """
 
 import numpy as np
@@ -60,10 +66,11 @@ class Canvas(app.Canvas):
             self.markers.symbol = self.markers.symbols[self.index]
             self.update()
         elif event.text == 's':
-            self.markers.scaling = not self.markers.scaling
+            self.markers.scaling = "fixed" if self.markers.scaling != "fixed" else "scene"
             self.update()
 
 
 if __name__ == '__main__':
+    print(__doc__)
     canvas = Canvas()
     app.run()

{vispy-0.12.2 → 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/instanced_mesh.py

@@ -0,0 +1,117 @@
+# -*- coding: utf-8 -*-
+# vispy: gallery 5
+# -----------------------------------------------------------------------------
+# Copyright (c) Vispy Development Team. All Rights Reserved.
+# Distributed under the (new) BSD License. See LICENSE.txt for more info.
+# -----------------------------------------------------------------------------
+"""
+Instanced rendering of arbitrarily transformed meshes
+=====================================================
+"""
+
+from vispy import app, gloo, visuals, scene, use
+import numpy as np
+from scipy.spatial.transform import Rotation
+from vispy.io import read_mesh, load_data_file
+
+# full gl+ context is required for instanced rendering
+use(gl='gl+')
+
+
+vertex_shader = """
+// these attributes will be defined on an instance basis
+attribute vec3 shift;
+attribute vec4 color;
+attribute vec3 transform_x;
+attribute vec3 transform_y;
+attribute vec3 transform_z;
+
+varying vec4 v_color;
+
+void main() {
+    v_color = color;
+    // transform is generated from column vectors (new basis vectors)
+    // https://en.wikibooks.org/wiki/GLSL_Programming/Vector_and_Matrix_Operations#Constructors
+    mat3 instance_transform = mat3(transform_x, transform_y, transform_z);
+    vec3 pos_rotated = instance_transform * $position;
+    vec4 pos_shifted = vec4(pos_rotated + shift, 1);
+    gl_Position = $transform(pos_shifted);
+}
+"""
+
+fragment_shader = """
+varying vec4 v_color;
+
+void main() {
+  gl_FragColor = v_color;
+}
+"""
+
+
+class InstancedMeshVisual(visuals.Visual):
+    def __init__(self, vertices, faces, positions, colors, transforms, subdivisions=5):
+        visuals.Visual.__init__(self, vertex_shader, fragment_shader)
+
+        self.set_gl_state('translucent', depth_test=True, cull_face=True)
+        self._draw_mode = 'triangles'
+
+        # set up vertex and index buffer
+        self.vbo = gloo.VertexBuffer(vertices.astype(np.float32))
+        self.shared_program.vert['position'] = self.vbo
+        self._index_buffer = gloo.IndexBuffer(data=faces.astype(np.uint32))
+
+        # create a vertex buffer with a divisor argument of 1. This means that the
+        # attribute value is set to the next element of the array every 1 instance.
+        # The length of the array multiplied by the divisor determines the number
+        # of instances
+        self.shifts = gloo.VertexBuffer(positions.astype(np.float32), divisor=1)
+        self.shared_program['shift'] = self.shifts
+
+        # vispy does not handle matrix attributes (likely requires some big changes in GLIR)
+        # so we decompose it into three vec3; (column vectors of the matrix)
+        transforms = transforms.astype(np.float32)
+        self.transforms_x = gloo.VertexBuffer(transforms[..., 0].copy(), divisor=1)
+        self.transforms_y = gloo.VertexBuffer(transforms[..., 1].copy(), divisor=1)
+        self.transforms_z = gloo.VertexBuffer(transforms[..., 2].copy(), divisor=1)
+        self.shared_program['transform_x'] = self.transforms_x
+        self.shared_program['transform_y'] = self.transforms_y
+        self.shared_program['transform_z'] = self.transforms_z
+
+        # we can provide additional buffers with different divisors, as long as the
+        # amount of instances (length * divisor) is the same. In this case, we will change
+        # color every 5 instances
+        self.color = gloo.VertexBuffer(colors.astype(np.float32), divisor=1)
+        self.shared_program['color'] = self.color
+
+    def _prepare_transforms(self, view):
+        view.view_program.vert['transform'] = view.get_transform()
+
+
+# create a visual node class to add it to the canvas
+InstancedMesh = scene.visuals.create_visual_node(InstancedMeshVisual)
+
+# set up vanvas
+canvas = scene.SceneCanvas(keys='interactive', show=True)
+view = canvas.central_widget.add_view()
+view.camera = 'arcball'
+view.camera.scale_factor = 1000
+
+N = 1000
+
+mesh_file = load_data_file('orig/triceratops.obj.gz')
+vertices, faces, _, _ = read_mesh(mesh_file)
+
+np.random.seed(0)
+pos = (np.random.rand(N, 3) - 0.5) * 1000
+colors = np.random.rand(N, 4)
+transforms = Rotation.random(N).as_matrix()
+
+multimesh = InstancedMesh(vertices * 10, faces, pos, colors, transforms, parent=view.scene)
+# global transforms are applied correctly after the individual instance transforms!
+multimesh.transform = visuals.transforms.STTransform(scale=(3, 2, 1))
+
+
+if __name__ == '__main__':
+    import sys
+    if sys.flags.interactive != 1:
+        app.run()

vispy-0.14.0/examples/scene/instanced_mesh_visual.py

@@ -0,0 +1,108 @@
+# -*- 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.
+# -----------------------------------------------------------------------------
+"""
+Instanced Mesh Visual
+=====================
+
+Show usage of the InstancedMesh visual and its filters.
+"""
+
+from itertools import cycle
+
+import numpy as np
+from scipy.spatial.transform import Rotation
+from vispy import app, scene, use
+from vispy.io import imread, load_data_file, read_mesh
+from vispy.scene.visuals import InstancedMesh
+from vispy.visuals.filters import InstancedShadingFilter, WireframeFilter, TextureFilter
+
+# needed for instanced rendering to work
+use(gl='gl+')
+
+
+mesh_path = load_data_file('spot/spot.obj.gz')
+texture_path = load_data_file('spot/spot.png')
+vertices, faces, normals, texcoords = read_mesh(mesh_path)
+texture = np.flipud(imread(texture_path))
+
+canvas = scene.SceneCanvas(keys='interactive', bgcolor='white', show=True)
+view = canvas.central_widget.add_view()
+
+view.camera = 'arcball'
+view.camera.depth_value = 10 * (vertices.max() - vertices.min())
+
+n_instances = 100
+
+instance_colors = np.random.rand(n_instances, 3).astype(np.float32)
+instance_positions = ((np.random.rand(n_instances, 3) - 0.5) * 10).astype(np.float32)
+face_colors = np.random.rand(len(faces), 3)
+instance_transforms = Rotation.random(n_instances).as_matrix().astype(np.float32)
+
+# Create a colored `MeshVisual`.
+mesh = InstancedMesh(
+    vertices,
+    faces,
+    instance_colors=instance_colors,
+    face_colors=face_colors,
+    instance_positions=instance_positions,
+    instance_transforms=instance_transforms,
+    parent=view.scene,
+)
+
+
+wireframe_filter = WireframeFilter(width=1)
+shading_filter = InstancedShadingFilter('smooth', shininess=1)
+texture_filter = TextureFilter(texture, texcoords)
+mesh.attach(wireframe_filter)
+mesh.attach(shading_filter)
+mesh.attach(texture_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_cycle = cycle(['flat', None, 'smooth'])
+color_cycle = cycle([None, instance_colors])
+face_color_cycle = cycle([None, face_colors])
+
+
+@canvas.events.key_press.connect
+def on_key_press(event):
+    if event.key == "t":
+        texture_filter.enabled = not texture_filter.enabled
+        canvas.update()
+    if event.key == 's':
+        shading_filter.shading = next(shading_cycle)
+        canvas.update()
+    if event.key == 'c':
+        mesh.instance_colors = next(color_cycle)
+        canvas.update()
+    if event.key == 'f':
+        mesh.set_data(
+            vertices=vertices,
+            faces=faces,
+            face_colors=next(face_color_cycle),
+        )
+        canvas.update()
+    if event.key == 'w':
+        wireframe_filter.enabled = not wireframe_filter.enabled
+        canvas.update()
+
+
+if __name__ == "__main__":
+    app.run()