vispy 0.14.2__cp312-cp312-win_amd64.whl → 0.15.0__cp312-cp312-win_amd64.whl

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
@@ -97,7 +99,7 @@ class Triangulation(object):
         self._tops = self.edges.max(axis=1)
         self._bottoms = self.edges.min(axis=1)
 
-        # inintialize sweep front
+        # initialize sweep front
         # values in this list are indexes into self.pts
         self._front = [0, 2, 1]
 
@@ -183,7 +185,7 @@ class Triangulation(object):
                 for j in self._bottoms[self._tops == i]:
                     # Make sure edge (j, i) is present in mesh
                     # because edge event may have created a new front list
-                    self._edge_event(i, j)
+                    self._edge_event(i, int(j))
                     front = self._front
 
         self._finalize()
@@ -201,7 +203,7 @@ class Triangulation(object):
         while k < idx-1:
             # if edges lie in counterclockwise direction, then signed area
             # is positive
-            if self._iscounterclockwise(front[k], front[k+1], front[k+2]):
+            if self._orientation((front[k], front[k+1]), front[k+2]) < 0:
                 self._add_tri(front[k], front[k+1], front[k+2])
                 front.pop(k+1)
                 idx -= 1
@@ -396,7 +398,7 @@ class Triangulation(object):
 
                     upper_polygon.append(front[front_index+front_dir])
 
-        # (iii) triangluate empty areas
+        # (iii) triangulate empty areas
 
         for polygon in [lower_polygon, upper_polygon]:
             dist = self._distances_from_line((i, j), polygon)
@@ -671,13 +673,6 @@ class Triangulation(object):
         d = (a + c - b) / ((4 * a * c)**0.5)
         return d
 
-    def _iscounterclockwise(self, a, b, c):
-        # Check if the points lie in counter-clockwise order or not
-        A = self.pts[a]
-        B = self.pts[b]
-        C = self.pts[c]
-        return np.cross(B-A, C-B) > 0
-
     def _edges_intersect(self, edge1, edge2):
         """Return 1 if edges intersect completely (endpoints excluded)"""
         h12 = self._intersect_edge_arrays(self.pts[np.array(edge1)],
@@ -739,14 +734,14 @@ 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):
         # sanity check
         assert a != b and b != c and c != a
 
-        # ignore flat tris
+        # ignore tris with duplicate points
         pa = self.pts[a]
         pb = self.pts[b]
         pc = self.pts[c]
@@ -759,8 +754,13 @@ class Triangulation(object):
                 raise Exception("Cannot add %s; already have %s" %
                                 ((a, b, c), t))
 
+        # ignore lines
+        orientation = self._orientation((a, b), c)
+        if orientation == 0:
+            return
+
         # TODO: should add to edges_lookup after legalization??
-        if self._iscounterclockwise(a, b, c):
+        if orientation < 0:
             assert (a, b) not in self._edges_lookup
             assert (b, c) not in self._edges_lookup
             assert (c, a) not in self._edges_lookup

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

@@ -1283,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/program.py

@@ -362,7 +362,7 @@ class Program(GLObject):
                         data = TextureCube(data)
                     else:
                         # This should not happen
-                        raise RuntimeError('Unknown type %s' % type_)
+                        raise RuntimeError('Unknown type %s for %s' % (type_, name))
                     # Store and send GLIR command
                     self._user_variables[name] = data
                     self.glir.associate(data.glir)
@@ -442,7 +442,7 @@ class Program(GLObject):
                     self._glir.command('ATTRIBUTE', self._id,
                                        name, type_, value, divisor)
             else:
-                raise KeyError('Cannot set data for a %s.' % kind)
+                raise KeyError('Cannot set data for a %s (%s).' % (kind, name))
         else:
             # This variable is not defined in the current source code,
             # so we cannot establish whether this is a uniform or

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/scene/cameras/arcball.py

@@ -6,7 +6,6 @@ from __future__ import division
 
 import numpy as np
 
-
 from ...util import transforms
 from ...util.quaternion import Quaternion
 from ...visuals.transforms import MatrixTransform
@@ -57,7 +56,7 @@ class ArcballCamera(Base3DRotationCamera):
 
     def _update_rotation(self, event):
         """Update rotation parmeters based on mouse movement"""
-        p2 = event.mouse_event.pos
+        p2 = event.pos[:2]
         if self._event_value is None:
             self._event_value = p2
         wh = self._viewbox.size

vispy/scene/cameras/base_camera.py

@@ -3,6 +3,7 @@
 # Distributed under the (new) BSD License. See LICENSE.txt for more info.
 
 from __future__ import division
+from contextlib import contextmanager
 
 from ...util import keys
 from ..node import Node
@@ -211,11 +212,14 @@ class BaseCamera(Node):
     @center.setter
     def center(self, val):
         if len(val) == 2:
-            self._center = float(val[0]), float(val[1]), 0.0
+            center = float(val[0]), float(val[1]), 0.0
         elif len(val) == 3:
-            self._center = float(val[0]), float(val[1]), float(val[2])
+            center = float(val[0]), float(val[1]), float(val[2])
         else:
             raise ValueError('Center must be a 2 or 3 element tuple')
+        if center == self._center:
+            return
+        self._center = center
         self.view_changed()
 
     @property
@@ -233,6 +237,12 @@ class BaseCamera(Node):
         self._fov = fov
         self.view_changed()
 
+    @contextmanager
+    def _block_updates(self):
+        prev, self._resetting = self._resetting, True
+        yield
+        self._resetting = prev
+
     # Camera methods
 
     def set_range(self, x=None, y=None, z=None, margin=0.05):
@@ -276,31 +286,30 @@ class BaseCamera(Node):
             return
 
         # There is a viewbox, we're going to set the range for real
-        self._resetting = True
+        with self._block_updates():
 
-        # Get bounds from viewbox if not given
-        if all([(b is None) for b in bounds]):
-            bounds = self._viewbox.get_scene_bounds()
-        else:
-            for i in range(3):
-                if bounds[i] is None:
-                    bounds[i] = self._viewbox.get_scene_bounds(i)
-
-        # Calculate ranges and margins
-        ranges = [b[1] - b[0] for b in bounds]
-        margins = [(r*margin or 0.1) for r in ranges]
-        # Assign limits for this camera
-        bounds_margins = [(b[0]-m, b[1]+m) for b, m in zip(bounds, margins)]
-        self._xlim, self._ylim, self._zlim = bounds_margins
-        # Store center location
-        if (not init) or (self._center is None):
-            self._center = [(b[0] + r / 2) for b, r in zip(bounds, ranges)]
-
-        # Let specific camera handle it
-        self._set_range(init)
+            # Get bounds from viewbox if not given
+            if all([(b is None) for b in bounds]):
+                bounds = self._viewbox.get_scene_bounds()
+            else:
+                for i in range(3):
+                    if bounds[i] is None:
+                        bounds[i] = self._viewbox.get_scene_bounds(i)
+
+            # Calculate ranges and margins
+            ranges = [b[1] - b[0] for b in bounds]
+            margins = [(r*margin or 0.1) for r in ranges]
+            # Assign limits for this camera
+            bounds_margins = [(b[0]-m, b[1]+m) for b, m in zip(bounds, margins)]
+            self._xlim, self._ylim, self._zlim = bounds_margins
+            # Store center location
+            if (not init) or (self._center is None):
+                self._center = [(b[0] + r / 2) for b, r in zip(bounds, ranges)]
+
+            # Let specific camera handle it
+            self._set_range(init)
 
         # Finish
-        self._resetting = False
         self.view_changed()
 
     def _set_range(self, init):
@@ -357,32 +366,34 @@ class BaseCamera(Node):
         state = state or {}
         state.update(kwargs)
 
-        # In first pass, process tuple keys which select subproperties. This
-        # is an undocumented feature used for selective linking of camera state.
-        #
-        # Subproperties are handled by first copying old value of the root
-        # property, then setting the subproperty on this copy, and finally
-        # assigning the copied object back to the camera property. There needs
-        # to be an assignment of the root property so setters are called and
-        # update is triggered.
-        for key in list(state.keys()):
-            if isinstance(key, tuple):
-                key1 = key[0]
-                if key1 not in state:
-                    root_prop = getattr(self, key1)
-                    # We make copies by passing the old object to the type's
-                    # constructor. This needs to be supported as is the case in
-                    # e.g. the geometry.Rect class.
-                    state[key1] = root_prop.__class__(root_prop)
-                nested_setattr(state[key1], key[1:], state[key])
-
-        # In second pass, assign the new root properties.
-        for key, val in state.items():
-            if isinstance(key, tuple):
-                continue
-            if key not in self._state_props:
-                raise KeyError('Not a valid camera state property %r' % key)
-            setattr(self, key, val)
+        with self._block_updates():
+            # In first pass, process tuple keys which select subproperties. This
+            # is an undocumented feature used for selective linking of camera state.
+            #
+            # Subproperties are handled by first copying old value of the root
+            # property, then setting the subproperty on this copy, and finally
+            # assigning the copied object back to the camera property. There needs
+            # to be an assignment of the root property so setters are called and
+            # update is triggered.
+            for key in list(state.keys()):
+                if isinstance(key, tuple):
+                    key1 = key[0]
+                    if key1 not in state:
+                        root_prop = getattr(self, key1)
+                        # We make copies by passing the old object to the type's
+                        # constructor. This needs to be supported as is the case in
+                        # e.g. the geometry.Rect class.
+                        state[key1] = root_prop.__class__(root_prop)
+                    nested_setattr(state[key1], key[1:], state[key])
+
+            # In second pass, assign the new root properties.
+            for key, val in state.items():
+                if isinstance(key, tuple):
+                    continue
+                if key not in self._state_props:
+                    raise KeyError('Not a valid camera state property %r' % key)
+                setattr(self, key, val)
+        self.view_changed()
 
     def link(self, camera, props=None, axis=None):
         """Link this camera with another camera of the same type
@@ -508,6 +519,8 @@ class BaseCamera(Node):
 
     def _set_scene_transform(self, tr):
         """Called by subclasses to configure the viewbox scene transform."""
+        if self._resetting:
+            return
         # todo: check whether transform has changed, connect to
         # transform.changed event
         pre_tr = self.pre_transform

vispy/scene/cameras/panzoom.py

@@ -164,7 +164,7 @@ class PanZoomCamera(BaseCamera):
     def center(self, center):
         if not (isinstance(center, (tuple, list)) and len(center) in (2, 3)):
             raise ValueError('center must be a 2 or 3 element tuple')
-        rect = Rect(self.rect) or Rect(*DEFAULT_RECT_TUPLE)
+        rect = Rect(self.rect) or Rect(*DEFAULT_RECT_TUPLE)  # make a copy of self.rect
         rect.center = center[:2]
         self.rect = rect
 
@@ -246,6 +246,9 @@ class PanZoomCamera(BaseCamera):
             event.handled = False
 
     def _update_transform(self):
+        if self._resetting:  # base camera linking operation
+            return
+
         rect = self.rect
         self._real_rect = Rect(rect)
         vbr = self._viewbox.rect.flipped(x=self.flip[0], y=(not self.flip[1]))

vispy/scene/cameras/perspective.py

@@ -80,7 +80,10 @@ class PerspectiveCamera(BaseCamera):
 
     @scale_factor.setter
     def scale_factor(self, value):
-        self._scale_factor = abs(float(value))
+        value = abs(float(value))
+        if value == self._scale_factor:
+            return
+        self._scale_factor = value
         self.view_changed()
 
     @property
@@ -137,6 +140,8 @@ class PerspectiveCamera(BaseCamera):
         # Do we have a viewbox
         if self._viewbox is None:
             return
+        if self._resetting:  # base camera linking operation
+            return
 
         # Calculate viewing range for x and y
         fx = fy = self._scale_factor

vispy/scene/cameras/turntable.py

@@ -73,6 +73,9 @@ class TurntableCamera(Base3DRotationCamera):
         super(TurntableCamera, self).__init__(fov=fov, **kwargs)
 
         # Set camera attributes
+        self._azimuth = azimuth
+        self._elevation = elevation
+        self._roll = roll
         self.azimuth = azimuth
         self.elevation = elevation
         self.roll = roll
@@ -90,7 +93,10 @@ class TurntableCamera(Base3DRotationCamera):
     @elevation.setter
     def elevation(self, elev):
         elev = float(elev)
-        self._elevation = min(90, max(-90, elev))
+        elev = min(90, max(-90, elev))
+        if elev == self._elevation:
+            return
+        self._elevation = elev
         self.view_changed()
 
     @property
@@ -108,6 +114,8 @@ class TurntableCamera(Base3DRotationCamera):
             azim += 360
         while azim > 180:
             azim -= 360
+        if azim == self._azimuth:
+            return
         self._azimuth = azim
         self.view_changed()
 
@@ -123,6 +131,8 @@ class TurntableCamera(Base3DRotationCamera):
             roll += 360
         while roll > 180:
             roll -= 360
+        if roll == self._roll:
+            return
         self._roll = roll
         self.view_changed()
 

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/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

@@ -1,8 +1,13 @@
-# file generated by setuptools_scm
+# file generated by setuptools-scm
 # don't change, don't track in version control
+
+__all__ = ["__version__", "__version_tuple__", "version", "version_tuple"]
+
 TYPE_CHECKING = False
 if TYPE_CHECKING:
-    from typing import Tuple, Union
+    from typing import Tuple
+    from typing import Union
+
     VERSION_TUPLE = Tuple[Union[int, str], ...]
 else:
     VERSION_TUPLE = object
@@ -12,5 +17,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '0.14.2'
-__version_tuple__ = version_tuple = (0, 14, 2)
+__version__ = version = '0.15.0'
+__version_tuple__ = version_tuple = (0, 15, 0)

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):
@@ -290,15 +291,16 @@ class CPUScaledTextureMixin(_ScaledTextureMixin):
 
         range_min, range_max = self._data_limits
         clim_min, clim_max = self.clim
-        if clim_min == clim_max:
+        full_range = range_max - range_min
+        if clim_min == clim_max or full_range == 0:
             return 0, np.inf
-        clim_min = (clim_min - range_min) / (range_max - range_min)
-        clim_max = (clim_max - range_min) / (range_max - range_min)
+        clim_min = (clim_min - range_min) / full_range
+        clim_max = (clim_max - range_min) / full_range
         return clim_min, clim_max
 
     @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
@@ -311,7 +313,7 @@ class CPUScaledTextureMixin(_ScaledTextureMixin):
     def scale_and_set_data(self, data, offset=None, copy=True):
         """Upload new data to the GPU, scaling if necessary."""
         if self._data_dtype is None:
-            data.dtype == self._data_dtype
+            self._data_dtype = data.dtype
 
         # ensure dtype is the same as it was before, or funny things happen
         # no copy is performed unless asked for or necessary

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/filters/mesh.py

@@ -421,6 +421,7 @@ class ShadingFilter(Filter):
         ffunc = Function(self._shaders['fragment'])
 
         self._normals = VertexBuffer(np.zeros((0, 3), dtype=np.float32))
+        self._normals_cache = None
         vfunc['normal'] = self._normals
 
         super().__init__(vcode=vfunc, fcode=ffunc)
@@ -550,7 +551,11 @@ class ShadingFilter(Filter):
         )
 
         normals = self._visual.mesh_data.get_vertex_normals(indexed='faces')
-        self._normals.set_data(normals, convert=True)
+        if normals is not self._normals_cache:
+            # limit how often we upload new normal arrays
+            # gotcha: if normals are changed in place then this won't invalidate this cache
+            self._normals_cache = normals
+            self._normals.set_data(self._normals_cache, convert=True)
 
     def on_mesh_data_updated(self, event):
         self._update_data()