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

vispy/testing/_testing.py

@@ -14,7 +14,7 @@ import gc
 import pytest
 import functools
 
-from distutils.version import LooseVersion
+from packaging.version import Version
 
 from ..util.check_environment import has_backend
 
@@ -251,7 +251,7 @@ def has_ipython(version='3.0'):
     except Exception:
         return False, "IPython library not found"
     else:
-        if LooseVersion(IPython.__version__) >= LooseVersion(version):
+        if Version(IPython.__version__) >= Version(version):
             return True, "IPython present"
         else:
             message = (
@@ -284,8 +284,7 @@ def _has_scipy(min_version):
     try:
         assert isinstance(min_version, str)
         import scipy  # noqa, analysis:ignore
-        from distutils.version import LooseVersion
-        this_version = LooseVersion(scipy.__version__)
+        this_version = Version(scipy.__version__)
         if this_version < min_version:
             return False
     except Exception:

vispy/util/check_environment.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.
 import os
-from distutils.version import LooseVersion
+from packaging.version import Version
 
 from vispy.util import use_log_level
 
@@ -14,7 +14,7 @@ def has_matplotlib(version='1.2'):
     except Exception:
         has_mpl = False
     else:
-        if LooseVersion(matplotlib.__version__) >= LooseVersion(version):
+        if Version(matplotlib.__version__) >= Version(version):
             has_mpl = True
         else:
             has_mpl = False
@@ -27,8 +27,8 @@ def has_skimage(version='0.11'):
         import skimage
     except ImportError:
         return False
-    sk_version = LooseVersion(skimage.__version__)
-    return sk_version >= LooseVersion(version)
+    sk_version = Version(skimage.__version__)
+    return sk_version >= Version(version)
 
 
 def has_backend(backend, has=(), capable=(), out=()):

vispy/util/gallery_scraper.py

@@ -60,7 +60,7 @@ class VisPyGalleryScraper:
         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 = self._get_canvaslike_from_globals(block_vars["example_globals"])
+        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):
@@ -89,6 +89,7 @@ class VisPyGalleryScraper:
             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]
@@ -133,36 +134,38 @@ class VisPyGalleryScraper:
             frame_paths.append(frame_fn)
         return frame_paths
 
-    def _get_canvaslike_from_globals(self, globals_dict):
-        qt_widget = self._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
 
-    @staticmethod
-    def _get_qt_top_parent(globals_dict):
-        if "QWidget" not in globals_dict and "QMainWindow" not in globals_dict:
-            return None
-
-        qmainwindow = globals_dict.get("QMainWindow")
-        qwidget = globals_dict.get("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]
+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."""
@@ -174,6 +177,13 @@ class FrameGrabber:
         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
@@ -204,13 +214,19 @@ class FrameGrabber:
 
     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)
@@ -218,14 +234,16 @@ class FrameGrabber:
 
     @staticmethod
     def _qpixmap_to_ndarray(pixmap):
+        from PyQt5 import QtGui
         import numpy as np
-        im = pixmap.toImage()
+        im = pixmap.toImage().convertToFormat(QtGui.QImage.Format.Format_RGB32)
         size = pixmap.size()
         width = size.width()
         height = size.height()
-        im_bits = im.bits()
-        im_bits.setsize(height * width * 4)  # RGBA
-        return np.frombuffer(im_bits, np.uint8).reshape((height, width, 4))
+        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'

vispy/util/tests/test_gallery_scraper.py

@@ -16,6 +16,8 @@ except ImportError:
 
 from ..gallery_scraper import VisPyGalleryScraper
 
+pytest.importorskip("PyQt5", reason="Gallery scraper only supports PyQt5")
+
 
 def _create_fake_block_vars(canvas):
     block_vars = {

vispy/util/transforms.py

@@ -54,7 +54,7 @@ def scale(s, dtype=None):
 
 
 def rotate(angle, axis, dtype=None):
-    """The 3x3 rotation matrix for rotation about a vector.
+    """The 4x4 rotation matrix for rotation about a vector.
 
     Parameters
     ----------

vispy/util/wrappers.py

@@ -9,7 +9,7 @@ and vispy.gloo.gl can be used independently, they are not complely
 independent for some configureation. E.g. when using real ES 2.0,
 the app backend should use EGL and not a desktop OpenGL context. Also,
 we probably want it to be easy to configure vispy to use the ipython
-notebook backend, which requires specifc config of both app and gl.
+notebook backend, which requires specific config of both app and gl.
 
 This module does not have to be aware of the available app and gl
 backends, but it should be(come) aware of (in)compatibilities between

vispy/version.py

@@ -1,5 +1,4 @@
-# coding: utf-8
 # file generated by setuptools_scm
 # don't change, don't track in version control
-version = '0.9.5'
-version_tuple = (0, 9, 5)
+__version__ = version = '0.14.0'
+__version_tuple__ = version_tuple = (0, 14, 0)

vispy/visuals/__init__.py

@@ -17,9 +17,11 @@ from .cube import CubeVisual  # noqa
 from .ellipse import EllipseVisual  # noqa
 from .gridlines import GridLinesVisual  # noqa
 from .image import ImageVisual  # noqa
+from .image_complex import ComplexImageVisual  # noqa
 from .gridmesh import GridMeshVisual  # noqa
 from .histogram import HistogramVisual  # noqa
 from .infinite_line import InfiniteLineVisual  # noqa
+from .instanced_mesh import InstancedMeshVisual  # noqa
 from .isocurve import IsocurveVisual  # noqa
 from .isoline import IsolineVisual  # noqa
 from .isosurface import IsosurfaceVisual  # noqa

vispy/visuals/_scalable_textures.py

@@ -5,8 +5,7 @@ import warnings
 
 import numpy as np
 
-from vispy.gloo import Texture2D, Texture3D
-from vispy.gloo.texture import should_cast_to_f32
+from vispy.gloo.texture import Texture2D, Texture3D, convert_dtype_and_clip
 
 
 def get_default_clim_from_dtype(dtype):
@@ -210,7 +209,11 @@ class _ScaledTextureMixin:
 
     def scale_and_set_data(self, data, offset=None, copy=False):
         """Upload new data to the GPU."""
-        return self.set_data(data, offset=offset, copy=copy)
+        # we need to call super here or we get infinite recursion
+        return super().set_data(data, offset=offset, copy=copy)
+
+    def set_data(self, data, offset=None, copy=False):
+        self.scale_and_set_data(data, offset=offset, copy=copy)
 
 
 class CPUScaledTextureMixin(_ScaledTextureMixin):
@@ -295,29 +298,31 @@ class CPUScaledTextureMixin(_ScaledTextureMixin):
 
     @staticmethod
     def _scale_data_on_cpu(data, clim, copy=True):
-        if copy:
-            should_cast_to_f32(data.dtype)
-            data = np.array(data, dtype=np.float32, copy=copy)
-        elif not copy and not np.issubdtype(data.dtype, np.floating):
-            raise ValueError("Data must be of floating type for no copying to occur.")
-
+        data = np.array(data, dtype=np.float32, copy=copy)
         if clim[0] != clim[1]:
+            # we always must copy the data if we change it here, otherwise it might change
+            # unexpectedly the data held outside of here
+            if not copy:
+                data = data.copy()
             data -= clim[0]
-            data *= 1.0 / (clim[1] - clim[0])
-        if should_cast_to_f32(data.dtype):
-            data = data.astype(np.float32)
+            data *= 1 / (clim[1] - clim[0])
         return data
 
     def scale_and_set_data(self, data, offset=None, copy=True):
         """Upload new data to the GPU, scaling if necessary."""
-        self._data_dtype = data.dtype
+        if self._data_dtype is None:
+            data.dtype == self._data_dtype
+
+        # ensure dtype is the same as it was before, or funny things happen
+        # no copy is performed unless asked for or necessary
+        data = convert_dtype_and_clip(data, self._data_dtype, copy=copy)
 
         clim = self._clim
         is_auto = isinstance(clim, str) and clim == 'auto'
         if data.ndim == self._ndim or data.shape[self._ndim] == 1:
             if is_auto:
                 clim = get_default_clim_from_data(data)
-            data = self._scale_data_on_cpu(data, clim, copy=copy)
+            data = self._scale_data_on_cpu(data, clim, copy=False)
             data_limits = clim
         else:
             data_limits = get_default_clim_from_dtype(data.dtype)
@@ -326,7 +331,7 @@ class CPUScaledTextureMixin(_ScaledTextureMixin):
 
         self._clim = float(clim[0]), float(clim[1])
         self._data_limits = data_limits
-        return super().scale_and_set_data(data, offset=offset, copy=copy)
+        return super().scale_and_set_data(data, offset=offset, copy=False)
 
 
 class GPUScaledTextureMixin(_ScaledTextureMixin):
@@ -346,7 +351,6 @@ class GPUScaledTextureMixin(_ScaledTextureMixin):
     also give the texture permission to change formats in the future if
     new data is provided with a different data type.
 
-
     This class should only be used internally. For similar features where
     scaling occurs on the CPU see
     :class:`vispy.visuals._scalable_textures.CPUScaledTextureMixin`.
@@ -390,7 +394,6 @@ class GPUScaledTextureMixin(_ScaledTextureMixin):
             texture_format = np.dtype(texture_format).type
             if texture_format not in self._texture_dtype_format:
                 raise ValueError("Can't determine internal texture format for '{}'".format(texture_format))
-            should_cast_to_f32(texture_format)
             texture_format = self._texture_dtype_format[texture_format]
         # adjust internalformat for format of data (RGBA vs L)
         texture_format = texture_format.replace('r', 'rgba'[:num_channels])

vispy/visuals/collections/array_list.py

@@ -52,7 +52,7 @@ class ArrayList(object):
             an error is raised.
 
             If `itemsize` is 1-D array, the array will be divided into
-            elements whose succesive sizes will be picked from itemsize.
+            elements whose successive sizes will be picked from itemsize.
             If the sum of itemsize values is different from array size,
             an error is raised.
 
@@ -291,7 +291,7 @@ class ArrayList(object):
             an error is raised.
 
             If `itemsize` is 1-D array, the array will be divided into
-            elements whose succesive sizes will be picked from itemsize.
+            elements whose successive sizes will be picked from itemsize.
             If the sum of itemsize values is different from array size,
             an error is raised.
         """
@@ -394,7 +394,7 @@ class ArrayList(object):
             an error is raised.
 
             If `itemsize` is 1-D array, the array will be divided into
-            elements whose succesive sizes will be picked from itemsize.
+            elements whose successive sizes will be picked from itemsize.
             If the sum of itemsize values is different from array size,
             an error is raised.
         """

vispy/visuals/collections/base_collection.py

@@ -237,7 +237,7 @@ class BaseCollection(object):
             an error is raised.
 
             If `itemsize` is 1-D array, the array will be divided into
-            elements whose succesive sizes will be picked from itemsize.
+            elements whose successive sizes will be picked from itemsize.
             If the sum of itemsize values is different from array size,
             an error is raised.
         """

vispy/visuals/ellipse.py

@@ -79,7 +79,7 @@ class EllipseVisual(PolygonVisual):
 
         vertices = np.empty([num_segments + 2, 2], dtype=np.float32)
 
-        # split the total angle into num_segments intances
+        # split the total angle into num_segments instances
         theta = np.linspace(start_angle,
                             start_angle + np.deg2rad(span_angle),
                             num_segments + 1)

vispy/visuals/filters/__init__.py

@@ -2,8 +2,9 @@
 # Copyright (c) Vispy Development Team. All Rights Reserved.
 # Distributed under the (new) BSD License. See LICENSE.txt for more info.
 
-from .base_filter import Filter  # noqa
+from .base_filter import Filter, PrimitivePickingFilter  # noqa
 from .clipper import Clipper  # noqa
 from .color import Alpha, ColorFilter, IsolineFilter, ZColormapFilter  # noqa
 from .picking import PickingFilter  # noqa
-from .mesh import TextureFilter, ShadingFilter, WireframeFilter  # noqa
+from .markers import MarkerPickingFilter  # noqa
+from .mesh import TextureFilter, ShadingFilter, InstancedShadingFilter, WireframeFilter, FacePickingFilter  # noqa

vispy/visuals/filters/base_filter.py

@@ -2,6 +2,11 @@
 # Copyright (c) Vispy Development Team. All Rights Reserved.
 # Distributed under the (new) BSD License. See LICENSE.txt for more info.
 
+from abc import ABCMeta, abstractmethod
+
+import numpy as np
+
+from vispy.gloo import VertexBuffer
 from ..shaders import Function
 
 
@@ -120,3 +125,118 @@ class Filter(BaseFilter):
 
         self._attached = False
         self._visual = None
+
+
+class PrimitivePickingFilter(Filter, metaclass=ABCMeta):
+    """Abstract base class for Visual-specific filters to implement a
+    primitive-picking mode.
+
+    Subclasses must (and usually only need to) implement
+    :py:meth:`_get_picking_ids`.
+    """
+
+    def __init__(self, fpos=9, *, discard_transparent=False):
+        # fpos is set to 9 by default to put it near the end, but before the
+        # default PickingFilter
+        vfunc = Function("""\
+            varying vec4 v_marker_picking_color;
+            void prepare_marker_picking() {
+                v_marker_picking_color = $ids;
+            }
+        """)
+        ffunc = Function("""\
+            varying vec4 v_marker_picking_color;
+            void marker_picking_filter() {
+                if ( $enabled != 1 ) {
+                    return;
+                }
+                if ( $discard_transparent == 1 && gl_FragColor.a == 0.0 ) {
+                    discard;
+                }
+                gl_FragColor = v_marker_picking_color;
+            }
+        """)
+
+        self._id_colors = VertexBuffer(np.zeros((0, 4), dtype=np.float32))
+        vfunc['ids'] = self._id_colors
+        self._n_primitives = 0
+        super().__init__(vcode=vfunc, fcode=ffunc, fpos=fpos)
+        self.enabled = False
+        self.discard_transparent = discard_transparent
+
+    @abstractmethod
+    def _get_picking_ids(self):
+        """Return a 1D array of picking IDs for the vertices in the visual.
+
+        Generally, this method should be implemented to:
+            1. Calculate the number of primitives in the visual (may be
+            persisted in `self._n_primitives`).
+            2. Calculate a range of picking ids for each primitive in the
+            visual. IDs should start from 1, reserving 0 for the background. If
+            primitives comprise multiple vertices (triangles), ids may need to
+            be repeated.
+
+        The return value should be an array of uint32 with shape
+        (num_vertices,).
+
+        If no change to the picking IDs is needed (for example, the number of
+        primitives has not changed), this method should return `None`.
+        """
+        raise NotImplementedError(self)
+
+    def _update_id_colors(self):
+        """Calculate the colors encoding the picking IDs for the visual.
+
+        For performance, this method will not update the id colors VertexBuffer
+        if :py:meth:`_get_picking_ids` returns `None`.
+        """
+        # this should remain untouched
+        ids = self._get_picking_ids()
+        if ids is not None:
+            id_colors = self._pack_ids_into_rgba(ids)
+            self._id_colors.set_data(id_colors)
+
+    @staticmethod
+    def _pack_ids_into_rgba(ids):
+        """Pack an array of uint32 primitive ids into float32 RGBA colors."""
+        if ids.dtype != np.uint32:
+            raise ValueError(f"ids must be uint32, got {ids.dtype}")
+
+        return np.divide(
+            ids.view(np.uint8).reshape(-1, 4),
+            255,
+            dtype=np.float32
+        )
+
+    def _on_data_updated(self, event=None):
+        if not self.attached:
+            return
+        self._update_id_colors()
+
+    @property
+    def enabled(self):
+        return self._enabled
+
+    @enabled.setter
+    def enabled(self, e):
+        self._enabled = bool(e)
+        self.fshader['enabled'] = int(self._enabled)
+        self._on_data_updated()
+
+    @property
+    def discard_transparent(self):
+        return self._discard_transparent
+
+    @discard_transparent.setter
+    def discard_transparent(self, d):
+        self._discard_transparent = bool(d)
+        self.fshader['discard_transparent'] = int(self._discard_transparent)
+
+    def _attach(self, visual):
+        super()._attach(visual)
+        visual.events.data_updated.connect(self._on_data_updated)
+        self._on_data_updated()
+
+    def _detach(self, visual):
+        visual.events.data_updated.disconnect(self._on_data_updated)
+        super()._detach(visual)

vispy/visuals/filters/clipping_planes.py

@@ -2,6 +2,10 @@
 # Copyright (c) Vispy Development Team. All Rights Reserved.
 # Distributed under the (new) BSD License. See LICENSE.txt for more info.
 
+from __future__ import annotations
+
+from typing import Optional
+
 from functools import lru_cache
 
 import numpy as np
@@ -37,7 +41,7 @@ class PlanesClipper(Filter):
     }
     """
 
-    def __init__(self, clipping_planes=None, coord_system='scene'):
+    def __init__(self, clipping_planes: Optional[np.ndarray] = None, coord_system: str = 'scene'):
         tr = ['visual', 'scene', 'document', 'canvas', 'framebuffer', 'render']
         if coord_system not in tr:
             raise ValueError(f'Invalid coordinate system {coord_system}. Must be one of {tr}.')
@@ -48,6 +52,11 @@ class PlanesClipper(Filter):
             fcode=Function(self.FRAG_CODE), fhook='pre', fpos=1,
         )
 
+        # initialize clipping planes
+        self._clipping_planes = np.empty((0, 2, 3), dtype=np.float32)
+        self._clipping_planes_func = Function(self._build_clipping_planes_glsl(0))
+        self.fshader['clip_with_planes'] = self._clipping_planes_func
+
         v_position = Varying('v_position', 'vec4')
         self.vshader['v_position'] = v_position
         self.fshader['v_position'] = v_position
@@ -55,7 +64,7 @@ class PlanesClipper(Filter):
         self.clipping_planes = clipping_planes
 
     @property
-    def coord_system(self):
+    def coord_system(self) -> str:
         """
         Coordinate system used by the clipping planes (see visuals.transforms.transform_system.py)
         """
@@ -68,7 +77,7 @@ class PlanesClipper(Filter):
 
     @staticmethod
     @lru_cache(maxsize=10)
-    def _build_clipping_planes_func(n_planes):
+    def _build_clipping_planes_glsl(n_planes: int) -> str:
         """Build the code snippet used to clip the volume based on self.clipping_planes."""
         func_template = '''
             float clip_planes(vec3 loc) {{
@@ -87,24 +96,27 @@ class PlanesClipper(Filter):
         for idx in range(n_planes):
             all_clips.append(clip_template.format(idx=idx))
         formatted_code = func_template.format(clips=''.join(all_clips))
-        return Function(formatted_code)
+        return formatted_code
 
     @property
-    def clipping_planes(self):
+    def clipping_planes(self) -> np.ndarray:
         """Get the set of planes used to clip the mesh.
         Each plane is defined by a position and a normal vector (magnitude is irrelevant). Shape: (n_planes, 2, 3)
         """
         return self._clipping_planes
 
     @clipping_planes.setter
-    def clipping_planes(self, value):
+    def clipping_planes(self, value: Optional[np.ndarray]):
         if value is None:
-            value = np.empty([0, 2, 3])
-        self._clipping_planes = value
+            value = np.empty((0, 2, 3), dtype=np.float32)
+
+        # only recreate function if amount of clipping planes changes
+        if len(value) != len(self._clipping_planes):
+            self._clipping_planes_func = Function(self._build_clipping_planes_glsl(len(value)))
+            self.fshader['clip_with_planes'] = self._clipping_planes_func
 
-        clip_func = self._build_clipping_planes_func(len(value))
-        self.fshader['clip_with_planes'] = clip_func
+        self._clipping_planes = value
 
         for idx, plane in enumerate(value):
-            clip_func[f'clipping_plane_pos{idx}'] = tuple(plane[0])
-            clip_func[f'clipping_plane_norm{idx}'] = tuple(plane[1])
+            self._clipping_planes_func[f'clipping_plane_pos{idx}'] = tuple(plane[0])
+            self._clipping_planes_func[f'clipping_plane_norm{idx}'] = tuple(plane[1])

vispy/visuals/filters/markers.py

@@ -0,0 +1,28 @@
+import numpy as np
+
+from vispy.visuals.filters import PrimitivePickingFilter
+
+
+class MarkerPickingFilter(PrimitivePickingFilter):
+    """Filter used to color markers by a picking ID.
+
+    Note that the ID color uses the alpha channel, so this may not be used
+    with blending enabled.
+
+    Examples
+    --------
+    :ref:`sphx_glr_gallery_scene_marker_picking.py`
+    """
+
+    def _get_picking_ids(self):
+        if self._visual._data is None:
+            n_markers = 0
+        else:
+            n_markers = len(self._visual._data['a_position'])
+
+        # we only care about the number of markers changing
+        if self._n_primitives == n_markers:
+            return
+        self._n_primitives = n_markers
+
+        return np.arange(1, n_markers + 1, dtype=np.uint32)