vispy 0.14.1__cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl → 0.14.3__cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl

vispy/app/backends/_qt.py

@@ -386,9 +386,9 @@ class QtBaseCanvasBackend(BaseCanvasBackend):
 
         # must set physical size before setting visible or fullscreen
         # operations may make the size invalid
-        if hasattr(self, 'devicePixelRatio'):
+        if hasattr(self, 'devicePixelRatioF'):
             # handle high DPI displays in PyQt5
-            ratio = self.devicePixelRatio()
+            ratio = self.devicePixelRatioF()
         else:
             ratio = 1
         self._physical_size = (p.size[0] * ratio, p.size[1] * ratio)
@@ -421,7 +421,7 @@ class QtBaseCanvasBackend(BaseCanvasBackend):
 
         If display resolutions are the same this is essentially a no-op except for the redraw.
         If the display resolutions differ (HiDPI versus regular displays) the canvas needs to
-        be redrawn to reset the physical size based on the current `devicePixelRatio()` and
+        be redrawn to reset the physical size based on the current `devicePixelRatioF()` and
         redrawn with that new size.
 
         """
@@ -909,11 +909,11 @@ class CanvasBackendDesktop(QtBaseCanvasBackend, QGLWidget):
     def resizeGL(self, w, h):
         if self._vispy_canvas is None:
             return
-        if hasattr(self, 'devicePixelRatio'):
-            # We take into account devicePixelRatio, which is non-unity on
+        if hasattr(self, 'devicePixelRatioF'):
+            # We take into account devicePixelRatioF, which is non-unity on
             # e.g HiDPI displays.
-            # self.devicePixelRatio() is a float and should have been in Qt5 according to the documentation
-            ratio = self.devicePixelRatio()
+            # self.devicePixelRatioF() is a float and should have been in Qt5 according to the documentation
+            ratio = self.devicePixelRatioF()
             w = int(w * ratio)
             h = int(h * ratio)
         self._vispy_set_physical_size(w, h)

vispy/geometry/__init__.py

@@ -16,7 +16,7 @@ from .meshdata import MeshData  # noqa
 from .rect import Rect  # noqa
 from .triangulation import Triangulation, triangulate  # noqa
 from .torusknot import TorusKnot  # noqa
-from .calculations import (_calculate_normals, _fast_cross_3d,  # noqa
+from .calculations import (_calculate_normals, _cross_2d, _fast_cross_3d,  # noqa
                            resize)  # noqa
 from .generation import (create_arrow, create_box, create_cone,  # noqa
                          create_cube, create_cylinder, create_grid_mesh,  # noqa

vispy/geometry/calculations.py

@@ -7,8 +7,33 @@
 import numpy as np
 
 
-###############################################################################
-# These fast normal calculation routines are adapted from mne-python
+def _cross_2d(x, y):
+    """Compute the z-component of the cross product of (arrays of) 2D vectors.
+
+    This is meant to replicate the 2D functionality of np.cross(), which is
+    deprecated in numpy 2.0.
+
+    x and y must have broadcastable shapes, with the last dimension being 2.
+
+    Parameters
+    ----------
+    x : array
+        Input array 1, shape (..., 2).
+    y : array
+        Input array 2, shape (..., 2).
+
+    Returns
+    -------
+    z : array
+        z-component of cross products of x and y.
+
+    See: https://github.com/numpy/numpy/issues/26620
+    """
+    if x.shape[-1] != 2 or y.shape[-1] != 2:
+        raise ValueError("Input arrays must have shape (..., 2)")
+
+    return x[..., 0] * y[..., 1] - x[..., 1] * y[..., 0]
+
 
 def _fast_cross_3d(x, y):
     """Compute cross product between list of 3D vectors
@@ -47,6 +72,9 @@ def _fast_cross_3d(x, y):
         return np.cross(x, y)
 
 
+###############################################################################
+# These fast normal calculation routines are adapted from mne-python
+
 def _calculate_normals(rr, tris):
     """Efficiently compute vertex normals for triangulated surface"""
     # ensure highest precision for our summation/vectorization "trick"

vispy/geometry/triangulation.py

@@ -7,6 +7,8 @@ import numpy as np
 
 from collections import OrderedDict
 
+from .calculations import _cross_2d
+
 
 class Triangulation(object):
     """Constrained delaunay triangulation
@@ -676,7 +678,7 @@ class Triangulation(object):
         A = self.pts[a]
         B = self.pts[b]
         C = self.pts[c]
-        return np.cross(B-A, C-B) > 0
+        return _cross_2d(B - A, C - B) > 0
 
     def _edges_intersect(self, edge1, edge2):
         """Return 1 if edges intersect completely (endpoints excluded)"""
@@ -739,7 +741,7 @@ class Triangulation(object):
         """
         v1 = self.pts[point] - self.pts[edge[0]]
         v2 = self.pts[edge[1]] - self.pts[edge[0]]
-        c = np.cross(v1, v2)  # positive if v1 is CW from v2
+        c = _cross_2d(v1, v2)  # positive if v1 is CW from v2
         return 1 if c > 0 else (-1 if c < 0 else 0)
 
     def _add_tri(self, a, b, c):

vispy/gloo/buffer.py

@@ -10,7 +10,7 @@ from traceback import extract_stack, format_list
 import weakref
 
 from . globject import GLObject
-from ..util import logger
+from ..util import logger, np_copy_if_needed
 
 
 # ------------------------------------------------------------ Buffer class ---
@@ -70,7 +70,7 @@ class Buffer(GLObject):
             data is actually uploaded to GPU memory.
             Asking explicitly for a copy will prevent this behavior.
         """
-        data = np.array(data, copy=copy)
+        data = np.array(data, copy=copy or np_copy_if_needed)
         nbytes = data.nbytes
 
         if offset < 0:
@@ -98,7 +98,7 @@ class Buffer(GLObject):
             data is actually uploaded to GPU memory.
             Asking explicitly for a copy will prevent this behavior.
         """
-        data = np.array(data, copy=copy)
+        data = np.array(data, copy=copy or np_copy_if_needed)
         nbytes = data.nbytes
 
         if nbytes != self._nbytes:
@@ -283,7 +283,7 @@ class DataBuffer(Buffer):
 
         # Make sure data is an array
         if not isinstance(data, np.ndarray):
-            data = np.array(data, dtype=self.dtype, copy=False)
+            data = np.array(data, dtype=self.dtype)
 
         # Make sure data is big enough
         if data.size < stop - start:

vispy/gloo/gl/tests/test_functionality.py

@@ -192,8 +192,10 @@ quad = np.array([[0, 0, 0], [-1, 0, 0], [-1, -1, 0],
 N = quad.shape[0] * 4
 
 # buf3 contains coordinates in device coordinates for four quadrants
-buf3 = np.row_stack([quad + (0, 0, 0), quad + (0, 1, 0),
-                     quad + (1, 1, 0), quad + (1, 0, 0)]).astype(np.float32)
+buf3 = np.vstack([
+    quad + (0, 0, 0), quad + (0, 1, 0),
+    quad + (1, 1, 0), quad + (1, 0, 0),
+]).astype(np.float32)
 
 # buf2 is texture coords. Note that this is a view on buf2
 buf2 = ((buf3+1.0)*0.5)[:, :2]   # not C-contiguous

vispy/gloo/glir.py

@@ -1045,6 +1045,9 @@ class GlirProgram(GlirObject):
         'vec2': (2, gl.GL_FLOAT, np.float32),
         'vec3': (3, gl.GL_FLOAT, np.float32),
         'vec4': (4, gl.GL_FLOAT, np.float32),
+        'ivec2': (2, gl.GL_INT, np.int32),
+        'ivec3': (3, gl.GL_INT, np.int32),
+        'ivec4': (4, gl.GL_INT, np.int32),
         'int': (1, gl.GL_INT, np.int32),
         'bool': (1, gl.GL_BOOL, np.int32)
     }
@@ -1280,8 +1283,13 @@ class GlirProgram(GlirObject):
                 gl.glBindBuffer(gl.GL_ARRAY_BUFFER, vbo_handle)
                 gl.glEnableVertexAttribArray(attr_handle)
                 func(attr_handle, *args)
-                if divisor is not None:
-                    gl.glVertexAttribDivisor(attr_handle, divisor)
+                if hasattr(gl, "glVertexAttribDivisor"):
+                    gl.glVertexAttribDivisor(attr_handle, divisor or 0)
+                elif divisor is not None:
+                    logger.warning(
+                        'Instanced rendering is not supported by the current'
+                        f'backend ("{gl.current_backend.__name__}")'
+                    )
             else:
                 gl.glBindBuffer(gl.GL_ARRAY_BUFFER, 0)
                 gl.glDisableVertexAttribArray(attr_handle)

vispy/gloo/texture.py

@@ -11,6 +11,7 @@ import warnings
 
 from .globject import GLObject
 from .util import check_enum
+from ..util import np_copy_if_needed
 
 
 def get_dtype_limits(dtype):
@@ -29,7 +30,7 @@ def convert_dtype_and_clip(data, dtype, copy=False):
     new_min, new_max = get_dtype_limits(dtype)
     if new_max >= old_max and new_min <= old_min:
         # no need to clip
-        return np.array(data, dtype=dtype, copy=copy)
+        return np.array(data, dtype=dtype, copy=copy or np_copy_if_needed)
     else:
         # to reduce copying, we clip into a pre-generated array of the right dtype
         new_data = np.empty_like(data, dtype=dtype)
@@ -158,7 +159,7 @@ class BaseTexture(GLObject):
         if data is not None:
             if shape is not None:
                 raise ValueError('Texture needs data or shape, not both.')
-            data = np.array(data, copy=False)
+            data = np.array(data)
             # So we can test the combination
             self._resize(data.shape, format, internalformat)
             self._set_data(data)
@@ -427,7 +428,7 @@ class BaseTexture(GLObject):
 
         # Make sure data is an array
         if not isinstance(data, np.ndarray):
-            data = np.array(data, copy=False)
+            data = np.array(data)
         # Make sure data is big enough
         if data.shape != shape:
             data = np.resize(data, shape)

vispy/plot/plotwidget.py

@@ -267,7 +267,7 @@ class PlotWidget(scene.Widget):
         if meshdata is not None:
             if not all(x is None for x in (vertices, faces, fname)):
                 raise ValueError('vertices, faces, and fname must be None if '
-                                 'fname is not None')
+                                 'meshdata is not None')
         else:
             meshdata = MeshData(vertices, faces, vertex_colors=vertex_colors,
                                 face_colors=face_colors)

vispy/testing/_runners.py

@@ -164,7 +164,9 @@ def _flake():
         print('Running flake8... ')  # if end='', first error gets ugly
         sys.stdout.flush()
         try:
-            main()
+            # flake8 used to exit on failure, but instead `main` now returns an exit code
+            # see https://github.com/PyCQA/flake8/pull/1461
+            raise SystemExit(main())
         except SystemExit as ex:
             if ex.code in (None, 0):
                 pass  # do not exit yet, we want to print a success msg

vispy/testing/image_tester.py

@@ -157,6 +157,27 @@ def assert_image_approved(image, standard_file, message=None, **kwargs):
                     _save_failed_test(image, std_image, standard_file)
                 raise
 
+# TODO: check for more properties of image
+def assert_image_reasonable(image):
+    """Check that an image is reasonable.
+    
+    The given image is checked to not be completely black or white.
+    
+    Parameters:
+    -----------
+    image : (h, w, 4) ndarray or 'screenshot'
+        The test result to check
+    """
+    if isinstance(image, str) and image == "screenshot":
+        image = _screenshot(alpha=True)
+
+    # check dimensions
+    assert image.ndim == 3
+    assert image.shape[2] == 4
+
+    # check white or black
+    assert image[...,:3].max() > 0
+    assert image[...,:3].min() < 255
 
 def assert_image_match(im1, im2, min_corr=0.9, px_threshold=50.,
                        px_count=None, max_px_diff=None, avg_px_diff=None,

vispy/util/__init__.py

@@ -15,3 +15,18 @@ from . import fonts       # noqa
 from . import transforms  # noqa
 from .wrappers import use, run_subprocess  # noqa
 from .bunch import SimpleBunch  # noqa
+
+from typing import Optional
+
+import numpy as np
+
+# `copy` keyword semantics changed in NumPy 2.0
+# this maintains compatibility with older versions
+# if/when NumPy 2.0 becomes the minimum version, we can remove this
+# we don't worry about early dev versions of NumPy 2.0 (that may or may not have the kwarg) here
+# see:
+#  https://numpy.org/devdocs/numpy_2_0_migration_guide.html#adapting-to-changes-in-the-copy-keyword
+#  https://github.com/scipy/scipy/pull/20172
+np_copy_if_needed: Optional[bool] = None
+if np.lib.NumpyVersion(np.__version__) < "1.28.0":
+    np_copy_if_needed = False

vispy/version.py

@@ -12,5 +12,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '0.14.1'
-__version_tuple__ = version_tuple = (0, 14, 1)
+__version__ = version = '0.14.3'
+__version_tuple__ = version_tuple = (0, 14, 3)

vispy/visuals/_scalable_textures.py

@@ -6,6 +6,7 @@ import warnings
 import numpy as np
 
 from vispy.gloo.texture import Texture2D, Texture3D, convert_dtype_and_clip
+from vispy.util import np_copy_if_needed
 
 
 def get_default_clim_from_dtype(dtype):
@@ -298,7 +299,7 @@ class CPUScaledTextureMixin(_ScaledTextureMixin):
 
     @staticmethod
     def _scale_data_on_cpu(data, clim, copy=True):
-        data = np.array(data, dtype=np.float32, copy=copy)
+        data = np.array(data, dtype=np.float32, copy=copy or np_copy_if_needed)
         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

vispy/visuals/collections/array_list.py

@@ -73,7 +73,7 @@ class ArrayList(object):
                 if isinstance(data[0], (list, tuple)):
                     itemsize = [len(sublist) for sublist in data]
                     data = [item for sublist in data for item in sublist]
-            self._data = np.array(data, copy=False)
+            self._data = np.array(data)
             self._size = self._data.size
 
             # Default is one group with all data inside
@@ -88,7 +88,7 @@ class ArrayList(object):
                     _itemsize = np.ones(
                         self._count, dtype=int) * (self._size // self._count)
                 else:
-                    _itemsize = np.array(itemsize, copy=False)
+                    _itemsize = np.array(itemsize)
                     self._count = len(itemsize)
                     if _itemsize.sum() != self._size:
                         raise ValueError("Cannot partition data as requested")
@@ -302,7 +302,7 @@ class ArrayList(object):
             itemsize = [len(sublist) for sublist in data]
             data = [item for sublist in data for item in sublist]
 
-        data = np.array(data, copy=False).ravel()
+        data = np.array(data).ravel()
         size = data.size
 
         # Check item size and get item number
@@ -313,7 +313,7 @@ class ArrayList(object):
                 _count = size // itemsize
                 _itemsize = np.ones(_count, dtype=int) * (size // _count)
             else:
-                _itemsize = np.array(itemsize, copy=False)
+                _itemsize = np.array(itemsize)
                 _count = len(itemsize)
                 if _itemsize.sum() != size:
                     raise ValueError("Cannot partition data as requested")

vispy/visuals/ellipse.py

@@ -27,7 +27,7 @@ class EllipseVisual(PolygonVisual):
         The width of the border in pixels
         Line widths > 1px are only
         guaranteed to work when using `border_method='agg'` method.
-    radius : float | tuple
+    radius : float | tuple | list | numpy.ndarray
         Radius or radii of the ellipse
         Defaults to  (0.1, 0.1)
     start_angle : float
@@ -65,13 +65,12 @@ class EllipseVisual(PolygonVisual):
     @staticmethod
     def _generate_vertices(center, radius, start_angle, span_angle,
                            num_segments):
-        if isinstance(radius, (list, tuple)):
+        if isinstance(radius, (list, tuple, np.ndarray)):
             if len(radius) == 2:
                 xr, yr = radius
             else:
-                raise ValueError("radius must be float or 2 value tuple/list"
-                                 " (got %s of length %d)" % (type(radius),
-                                                             len(radius)))
+                raise ValueError("radius must be float or 2 value tuple/list/numpy.ndarray "
+                                 f"(got {type(radius)} of length {len(radius)})")
         else:
             xr = yr = radius
 

vispy/visuals/image.py

@@ -16,6 +16,7 @@ from .transforms import NullTransform
 from .visual import Visual
 from ..io import load_spatial_filters
 from ._scalable_textures import CPUScaledTexture2D, GPUScaledTexture2D
+from ..util import np_copy_if_needed
 
 
 _VERTEX_SHADER = """
@@ -380,7 +381,7 @@ class ImageVisual(Visual):
         texture_format : str or None
 
         """
-        data = np.array(image, copy=copy)
+        data = np.array(image, copy=copy or np_copy_if_needed)
         if np.iscomplexobj(data):
             raise TypeError(
                 "Complex data types not supported. Please use 'ComplexImage' instead"

vispy/visuals/markers.py

@@ -4,7 +4,6 @@
 # Distributed under the (new) BSD License. See LICENSE.txt for more info.
 # -----------------------------------------------------------------------------
 """Marker Visual and shader definitions."""
-
 import numpy as np
 
 from ..color import ColorArray
@@ -497,9 +496,11 @@ class MarkersVisual(Visual):
         The symbol size in screen (or data, if scaling is on) px.
     edge_width : float or array or None
         The width of the symbol outline in screen (or data, if scaling is on) px.
+        Defaults to 1.0 if None or not provided and ``edge_width_rel`` is not
+        provided.
     edge_width_rel : float or array or None
-        The width as a fraction of marker size. Exactly one of
-        `edge_width` and `edge_width_rel` must be supplied.
+        The width as a fraction of marker size. Can not be specified along with
+        edge_width. A ValueError will be raised if both are provided.
     edge_color : Color | ColorArray
         The color used to draw each symbol outline.
     face_color : Color | ColorArray
@@ -580,7 +581,7 @@ class MarkersVisual(Visual):
 
         self.freeze()
 
-    def set_data(self, pos=None, size=10., edge_width=1., edge_width_rel=None,
+    def set_data(self, pos=None, size=10., edge_width=None, edge_width_rel=None,
                  edge_color='black', face_color='white',
                  symbol='o'):
         """Set the data used to display this visual.
@@ -593,9 +594,11 @@ class MarkersVisual(Visual):
             The symbol size in screen (or data, if scaling is on) px.
         edge_width : float or array or None
             The width of the symbol outline in screen (or data, if scaling is on) px.
+            Defaults to 1.0 if None or not provided and ``edge_width_rel`` is not
+        provided.
         edge_width_rel : float or array or None
-            The width as a fraction of marker size. Exactly one of
-            `edge_width` and `edge_width_rel` must be supplied.
+            The width as a fraction of marker size. Can not be specified along with
+            edge_width. A ValueError will be raised if both are provided.
         edge_color : Color | ColorArray
             The color used to draw each symbol outline.
         face_color : Color | ColorArray
@@ -603,9 +606,11 @@ class MarkersVisual(Visual):
         symbol : str or array
             The style of symbol used to draw each marker (see Notes).
         """
-        if (edge_width is not None) + (edge_width_rel is not None) != 1:
-            raise ValueError('exactly one of edge_width and edge_width_rel '
-                             'must be non-None')
+        if edge_width is not None and edge_width_rel is not None:
+            raise ValueError("either edge_width or edge_width_rel "
+                             "should be provided, not both")
+        elif edge_width is None and edge_width_rel is None:
+            edge_width = 1.0
 
         if edge_width is not None:
             edge_width = np.asarray(edge_width)
@@ -616,10 +621,6 @@ class MarkersVisual(Visual):
             if np.any(edge_width_rel < 0):
                 raise ValueError('edge_width_rel cannot be negative')
 
-        if symbol is not None:
-            if not np.all(np.isin(np.asarray(symbol), self.symbols)):
-                raise ValueError(f'symbols must one of {self.symbols}')
-
         edge_color = ColorArray(edge_color).rgba
         if len(edge_color) == 1:
             edge_color = edge_color[0]
@@ -648,7 +649,15 @@ class MarkersVisual(Visual):
             data['a_position'][:, :pos.shape[1]] = pos
             data['a_size'] = size
 
-            data['a_symbol'] = np.vectorize(self._symbol_shader_values.get)(symbol)
+            if symbol is None:
+                data["a_symbol"] = np.array(None)
+            else:
+                if isinstance(symbol, str):
+                    symbol = [symbol]
+                try:
+                    data['a_symbol'] = np.array([self._symbol_shader_values[x] for x in symbol])
+                except KeyError:
+                    raise ValueError(f'symbols must one of {self.symbols}')
 
             self._data = data
             self._vbo.set_data(data)

vispy/visuals/surface_plot.py

@@ -70,8 +70,8 @@ class SurfacePlotVisual(MeshVisual):
         if z is not None:
             if self._x is not None and z.shape[0] != len(self._x):
                 raise TypeError('Z values must have shape (len(x), len(y))')
-            if self._y is not None and z.shape[1] != len(self._y):
-                raise TypeError('Z values must have shape (len(x), len(y))')
+            if self._y is not None and z.shape[1] != self._y.shape[-1]:    
+                raise TypeError('Z values must have shape (len(x), len(y)) or (x.shape[0], y.shape[1])')
             self._z = z
             if (self.__vertices is not None and
                     self._z.shape != self.__vertices.shape[:2]):

vispy/visuals/tests/test_surface_plot.py

@@ -0,0 +1,52 @@
+# -*- coding: utf-8 -*-
+from vispy.scene.visuals import SurfacePlot 
+from vispy.scene import TurntableCamera
+from vispy.color import get_colormap
+from vispy.testing import requires_application, TestingCanvas, run_tests_if_main
+from vispy.testing.image_tester import assert_image_reasonable
+
+import numpy as np
+import pytest
+
+
+@requires_application()
+@pytest.mark.parametrize('x1dim', [True, False])
+@pytest.mark.parametrize('y1dim', [True, False])
+def test_surface_plot(x1dim:bool, y1dim:bool):
+    """Test SurfacePlot visual"""
+    with TestingCanvas(bgcolor='w') as c:
+        
+        # create data
+        nx, ny = (100, 150)
+        x = np.linspace(-2, 2, nx)
+        y = np.linspace(-3, 3, ny)
+        xv, yv = np.meshgrid(x, y, indexing="ij")
+        z = np.sin(xv**2 + yv**2)
+
+        view = c.central_widget.add_view()
+        view.camera = TurntableCamera(up='z', fov=60)
+
+        # color vertices
+        cnorm = z / abs(np.amax(z))
+        colormap = get_colormap("viridis").map(cnorm)
+        colormap.reshape(z.shape + (-1,))
+
+        # 1 or 2 dimensional x and y data
+        x_input = x if x1dim else xv
+        y_input = y if y1dim else yv
+
+        # create figure
+        surface = SurfacePlot(z=z,
+                              x=x_input,
+                              y=y_input,
+                              shading=None)
+        
+        surface.mesh_data.set_vertex_colors(colormap)
+
+        # c.draw_visual(surface) 
+        view.add(surface)
+
+        assert_image_reasonable(c.render())
+
+
+run_tests_if_main()

vispy/visuals/text/_sdf_cpu.pyx

@@ -7,6 +7,8 @@ cimport numpy as np
 from libc.math cimport sqrt
 cimport cython
 
+np.import_array()
+
 __all__ = ['_get_distance_field']
 
 dtype = np.float32

vispy/visuals/volume.py

@@ -417,8 +417,8 @@ _ATTENUATED_MIP_SNIPPETS = dict(
         // Scale and clamp accumulation in `sumval` by contrast limits so that:
         // * attenuation value does not depend on data values
         // * negative values do not amplify instead of attenuate
-        sumval = sumval + clamp((val - clim.x) / (clim.y - clim.x), 0.0, 1.0);
-        scale = exp(-u_attenuation * (sumval - 1) / u_relative_step_size);
+        sumval = sumval + u_relative_step_size * clamp((val - clim.x) / (clim.y - clim.x), 0.0, 1.0);
+        scale = exp(-u_attenuation * (sumval - 1));
         if( maxval > scale * clim.y ) {
             // stop if no chance of finding a higher maxval
             iter = nsteps;
@@ -1165,9 +1165,40 @@ class VolumeVisual(Visual):
 
     @relative_step_size.setter
     def relative_step_size(self, value):
+        """Set the relative step size used during raycasting.
+
+        Very small values give increased detail when rendering volumes with
+        few voxels, but values that are too small give worse performance
+        (framerate), in extreme cases causing a GPU hang and for the process
+        to be killed by the OS. See discussion at:
+
+        https://github.com/vispy/vispy/pull/2587
+
+        For this reason, this setter issues a warning when the value is
+        smaller than ``side_len / (2 * MAX_CANVAS_SIZE)``, where ``side_len``
+        is the smallest side of the volume and ``MAX_CANVAS_SIZE`` is what
+        we consider to be the largest likely monitor resolution along its
+        longest side: 7680 pixels, equivalent to an 8K monitor.
+
+        This setter also raises a ValueError when the value is 0 or negative.
+        """
         value = float(value)
-        if value < 0.1:
-            raise ValueError('relative_step_size cannot be smaller than 0.1')
+        side_len = np.min(self._vol_shape)
+        MAX_CANVAS_SIZE = 7680
+        minimum_val = side_len / (2 * MAX_CANVAS_SIZE)
+        if value <= 0:
+            raise ValueError('relative_step_size cannot be 0 or negative.')
+        elif value < minimum_val:
+            warnings.warn(
+                f'To display a volume of shape {self._vol_shape} without '
+                f'artifacts, you need a step size no smaller than {side_len} /'
+                f'(2 * {MAX_CANVAS_SIZE}) = {minimum_val:,.3g}. To prevent '
+                'extreme degradation in rendering performance, the provided '
+                f'value of {value} is being clipped to {minimum_val:,.3g}. If '
+                'you believe you need a smaller step size, please raise an '
+                'issue at https://github.com/vispy/vispy/issues.'
+            )
+            value = minimum_val
         self._relative_step_size = value
         self.shared_program['u_relative_step_size'] = value
 

{vispy-0.14.1.dist-info → vispy-0.14.3.dist-info}/LICENSE.txt

@@ -3,7 +3,7 @@ Vispy licensing terms
 
 Vispy is licensed under the terms of the (new) BSD license:
 
-Copyright (c) 2013-2023, Vispy Development Team. All rights reserved.
+Copyright (c) 2013-2024, Vispy Development Team. All rights reserved.
 
 Redistribution and use in source and binary forms, with or without
 modification, are permitted provided that the following conditions are met: