vispy 0.14.3__cp312-cp312-win_amd64.whl → 0.15.2__cp312-cp312-win_amd64.whl

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