vispy 0.15.0__cp313-cp313-macosx_10_13_x86_64.whl

vispy/scene/cameras/panzoom.py

@@ -0,0 +1,311 @@
+# -*- coding: utf-8 -*-
+# Copyright (c) Vispy Development Team. All Rights Reserved.
+# Distributed under the (new) BSD License. See LICENSE.txt for more info.
+
+from __future__ import division
+
+import numpy as np
+
+from .base_camera import BaseCamera
+from ...geometry import Rect
+from ...visuals.transforms import STTransform, MatrixTransform
+
+
+DEFAULT_RECT_TUPLE = (0, 0, 1, 1)
+
+
+class PanZoomCamera(BaseCamera):
+    """Camera implementing 2D pan/zoom mouse interaction.
+
+    For this camera, the ``scale_factor`` indicates the zoom level, and
+    the ``center`` indicates the center position of the view.
+
+    By default, this camera inverts the y axis of the scene. This usually
+    results in the scene +y axis pointing upward because widgets (including
+    ViewBox) have their +y axis pointing downward.
+
+    Parameters
+    ----------
+    rect : Rect
+        A Rect object or 4-element tuple that specifies the rectangular
+        area to show.
+    aspect : float | None
+        The aspect ratio (i.e. scaling) between x and y dimension of
+        the scene. E.g. to show a square image as square, the aspect
+        should be 1. If None (default) the x and y dimensions are scaled
+        independently.
+    **kwargs : dict
+        Keyword arguments to pass to `BaseCamera`.
+
+    Notes
+    -----
+    Interaction:
+
+        * LMB: pan the view
+        * RMB or scroll: zooms the view
+
+    """
+
+    _state_props = BaseCamera._state_props + ('rect', )
+
+    def __init__(self, rect=DEFAULT_RECT_TUPLE, aspect=None, **kwargs):
+        super(PanZoomCamera, self).__init__(**kwargs)
+
+        self.transform = STTransform()
+        self.tf_mat = MatrixTransform()
+
+        # Set camera attributes
+        self.aspect = aspect
+        self._rect = None
+        self.rect = rect
+
+    @property
+    def aspect(self):
+        """The ratio between the x and y dimension. E.g. to show a
+        square image as square, the aspect should be 1. If None, the
+        dimensions are scaled automatically, dependening on the
+        available space. Otherwise the ratio between the dimensions
+        is fixed.
+        """
+        return self._aspect
+
+    @aspect.setter
+    def aspect(self, value):
+        if value is None:
+            self._aspect = None
+        else:
+            self._aspect = float(value)
+        self.view_changed()
+
+    def zoom(self, factor, center=None):
+        """Zoom in (or out) at the given center
+
+        Parameters
+        ----------
+        factor : float or tuple
+            Fraction by which the scene should be zoomed (e.g. a factor of 2
+            causes the scene to appear twice as large).
+        center : tuple of 2-4 elements
+            The center of the view. If not given or None, use the
+            current center.
+        """
+        # Init some variables
+        center = center if (center is not None) else self.center
+        assert len(center) in (2, 3, 4)
+        # Get scale factor, take scale ratio into account
+        if np.isscalar(factor):
+            scale = [factor, factor]
+        else:
+            if len(factor) != 2:
+                raise TypeError("factor must be scalar or length-2 sequence.")
+            scale = list(factor)
+        if self.aspect is not None:
+            scale[0] = scale[1]
+
+        # Make a new object (copy), so that allocation will
+        # trigger view_changed:
+        rect = Rect(self.rect)
+        # Get space from given center to edges
+        left_space = center[0] - rect.left
+        right_space = rect.right - center[0]
+        bottom_space = center[1] - rect.bottom
+        top_space = rect.top - center[1]
+        # Scale these spaces
+        rect.left = center[0] - left_space * scale[0]
+        rect.right = center[0] + right_space * scale[0]
+        rect.bottom = center[1] - bottom_space * scale[1]
+        rect.top = center[1] + top_space * scale[1]
+        self.rect = rect
+
+    def pan(self, *pan):
+        """Pan the view.
+
+        Parameters
+        ----------
+        *pan : length-2 sequence
+            The distance to pan the view, in the coordinate system of the
+            scene.
+        """
+        if len(pan) == 1:
+            pan = pan[0]
+        self.rect = self.rect + pan
+
+    @property
+    def rect(self):
+        """The rectangular border of the ViewBox visible area.
+        
+        This is expressed in the coordinate system of the scene.
+        See :class:`~vispy.geometry.rect.Rect` for different ways this can
+        be specified.
+
+        Note that the rectangle can have negative width or height, in
+        which case the corresponding dimension is flipped (this flipping
+        is independent from the camera's ``flip`` property).
+        """
+        return self._rect
+
+    @rect.setter
+    def rect(self, args):
+        if isinstance(args, tuple):
+            rect = Rect(*args)
+        else:
+            rect = Rect(args)
+
+        if self._rect != rect:
+            self._rect = rect
+            self.view_changed()
+
+    @property
+    def center(self):
+        rect = self._rect
+        return (*rect.center, 0)
+
+    @center.setter
+    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)  # make a copy of self.rect
+        rect.center = center[:2]
+        self.rect = rect
+
+    def _set_range(self, init):
+        if init and self._rect is not None:
+            return
+        # Convert limits to rect
+        w = self._xlim[1] - self._xlim[0]
+        h = self._ylim[1] - self._ylim[0]
+        self.rect = self._xlim[0], self._ylim[0], w, h
+
+    def viewbox_resize_event(self, event):
+        """Modify the data aspect and scale factor, to adjust to
+        the new window size.
+
+        Parameters
+        ----------
+        event : instance of Event
+            The event.
+        """
+        self.view_changed()
+
+    def viewbox_mouse_event(self, event):
+        """
+        The SubScene received a mouse event; update transform
+        accordingly.
+
+        Parameters
+        ----------
+        event : instance of Event
+            The event.
+        """
+        if event.handled or not self.interactive:
+            return
+
+        # Scrolling
+        BaseCamera.viewbox_mouse_event(self, event)
+
+        if event.type == 'mouse_wheel':
+            center = self._scene_transform.imap(event.pos)
+            self.zoom((1 + self.zoom_factor)**(-event.delta[1] * 30), center)
+            event.handled = True
+        elif event.type == 'gesture_zoom':
+            center = self._scene_transform.imap(event.pos)
+            self.zoom(1 - event.scale, center)
+            event.handled = True
+        elif event.type == 'mouse_move':
+            if event.press_event is None:
+                return
+
+            modifiers = event.mouse_event.modifiers
+            p1 = event.mouse_event.press_event.pos
+            p2 = event.mouse_event.pos
+
+            if 1 in event.buttons and not modifiers:
+                # Translate
+                p1 = np.array(event.last_event.pos)[:2]
+                p2 = np.array(event.pos)[:2]
+                p1s = self._transform.imap(p1)
+                p2s = self._transform.imap(p2)
+                self.pan(p1s - p2s)
+                event.handled = True
+            elif 2 in event.buttons and not modifiers:
+                # Zoom
+                p1c = np.array(event.last_event.pos)[:2]
+                p2c = np.array(event.pos)[:2]
+                scale = ((1 + self.zoom_factor)**((p1c - p2c) *
+                                                  np.array([1, -1])))
+                center = self._transform.imap(event.press_event.pos[:2])
+                self.zoom(scale, center)
+                event.handled = True
+            else:
+                event.handled = False
+        elif event.type == 'mouse_press':
+            # accept the event if it is button 1 or 2.
+            # This is required in order to receive future events
+            event.handled = event.button in [1, 2]
+        else:
+            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]))
+        d = self.depth_value
+
+        # apply scale ratio constraint
+        if self._aspect is not None:
+            # Aspect ratio of the requested range
+            requested_aspect = (rect.width /
+                                rect.height if rect.height != 0 else 1)
+            # Aspect ratio of the viewbox
+            view_aspect = vbr.width / vbr.height if vbr.height != 0 else 1
+            # View aspect ratio needed to obey the scale constraint
+            constrained_aspect = abs(view_aspect / self._aspect)
+
+            if requested_aspect > constrained_aspect:
+                # view range needs to be taller than requested
+                dy = 0.5 * (rect.width / constrained_aspect - rect.height)
+                self._real_rect.top += dy
+                self._real_rect.bottom -= dy
+            else:
+                # view range needs to be wider than requested
+                dx = 0.5 * (rect.height * constrained_aspect - rect.width)
+                self._real_rect.left -= dx
+                self._real_rect.right += dx
+
+        # Apply mapping between viewbox and cam view
+        self.transform.set_mapping(self._real_rect, vbr, update=False)
+        # Scale z, so that the clipping planes are between -alot and +alot
+        self.transform.zoom((1, 1, 1 / d))
+
+        # We've now set self.transform, which represents our 2D
+        # transform When up is +z this is all. In other cases,
+        # self.transform is now set up correctly to allow pan/zoom, but
+        # for the scene we need a different (3D) mapping. When there
+        # is a minus in up, we simply look at the scene from the other
+        # side (as if z was flipped).
+        if self.up == '+z':
+            self.tf_mat.matrix = self.transform.as_matrix().matrix
+        else:
+            rr = self._real_rect
+            d = d if (self.up[0] == '+') else -d
+            pp1 = [(vbr.left, vbr.bottom, 0), (vbr.left, vbr.top, 0),
+                   (vbr.right, vbr.bottom, 0), (vbr.left, vbr.bottom, 1)]
+            # Get Mapping
+            if self.up[1] == 'z':
+                pp2 = [(rr.left, rr.bottom, 0), (rr.left, rr.top, 0),
+                       (rr.right, rr.bottom, 0), (rr.left, rr.bottom, d)]
+            elif self.up[1] == 'y':
+                pp2 = [(rr.left, 0, rr.bottom), (rr.left, 0, rr.top),
+                       (rr.right, 0, rr.bottom), (rr.left, d, rr.bottom)]
+            elif self.up[1] == 'x':
+                pp2 = [(0, rr.left, rr.bottom), (0, rr.left, rr.top),
+                       (0, rr.right, rr.bottom), (d, rr.left, rr.bottom)]
+
+            # Apply
+            self.tf_mat.set_mapping(np.array(pp2), np.array(pp1))
+
+        # Set on viewbox
+        self._set_scene_transform(self.tf_mat)

vispy/scene/cameras/perspective.py

@@ -0,0 +1,338 @@
+# -*- coding: utf-8 -*-
+# Copyright (c) Vispy Development Team. All Rights Reserved.
+# Distributed under the (new) BSD License. See LICENSE.txt for more info.
+
+from __future__ import division
+
+import math
+import numpy as np
+
+from .base_camera import BaseCamera
+from ...util import keys, transforms
+from ...visuals.transforms import MatrixTransform
+
+
+class PerspectiveCamera(BaseCamera):
+    """Base class for 3D cameras supporting orthographic and
+    perspective projections.
+
+    Parameters
+    ----------
+    fov : float
+        Field of view. Default 60.0.
+    scale_factor : scalar
+        A measure for the scale/range of the scene that the camera
+        should show. The exact meaning differs per camera type.
+    **kwargs : dict
+        Keyword arguments to pass to `BaseCamera`.
+    """
+
+    _state_props = ('scale_factor', 'center', 'fov')
+
+    def __init__(self, fov=60.0, scale_factor=None, center=None, **kwargs):
+        super(PerspectiveCamera, self).__init__(**kwargs)
+        # Camera transform
+        self.transform = MatrixTransform()
+
+        # Set camera attributes
+        self.fov = fov
+        self._scale_factor = None
+        self._center = None
+
+        # Only set if they are given. They're set during _set_range if None
+        if scale_factor is not None:
+            self.scale_factor = scale_factor
+        if center is not None:
+            self.center = center
+
+    def viewbox_mouse_event(self, event):
+        """The ViewBox received a mouse event; update transform
+        accordingly.
+        Default implementation adjusts scale factor when scolling.
+
+        Parameters
+        ----------
+        event : instance of Event
+            The event.
+        """
+        BaseCamera.viewbox_mouse_event(self, event)
+        if event.type == 'mouse_wheel':
+            s = 1.1 ** - event.delta[1]
+            self._scale_factor *= s
+            if self._distance is not None:
+                self._distance *= s
+            self.view_changed()
+        elif event.type == 'gesture_zoom':
+            s = 1 - event.scale
+            self._scale_factor *= s
+            if self._distance is not None:
+                self._distance *= s
+            self.view_changed()
+
+    @property
+    def scale_factor(self):
+        """The measure for the scale or range that the camera should cover
+
+        For the PanZoomCamera and TurnTableCamera this translates to
+        zooming: set to smaller values to zoom in.
+        """
+        return self._scale_factor
+
+    @scale_factor.setter
+    def scale_factor(self, value):
+        value = abs(float(value))
+        if value == self._scale_factor:
+            return
+        self._scale_factor = value
+        self.view_changed()
+
+    @property
+    def near_clip_distance(self):
+        """The distance of the near clipping plane from the camera's position."""
+        return self._near_clip_distance
+
+    def _set_range(self, init):
+        """Reset the camera view using the known limits."""
+        if init and (self._scale_factor is not None):
+            return  # We don't have to set our scale factor
+
+        # Get window size (and store factor now to sync with resizing)
+        w, h = self._viewbox.size
+        w, h = float(w), float(h)
+
+        if (w == 0) or (h == 0):
+            return
+
+        # Get range and translation for x and y
+        x1, y1, z1 = self._xlim[0], self._ylim[0], self._zlim[0]
+        x2, y2, z2 = self._xlim[1], self._ylim[1], self._zlim[1]
+        rx, ry, rz = (x2 - x1), (y2 - y1), (z2 - z1)
+
+        # Correct ranges for window size. Note that the window width
+        # influences the x and y data range, while the height influences
+        # the z data range.
+        if w / h > 1:
+            rx /= w / h
+            ry /= w / h
+        else:
+            rz /= h / w
+
+        # Convert to screen coordinates. In screen x, only x and y have effect.
+        # In screen y, all three dimensions have effect. The idea of the lines
+        # below is to calculate the range on screen when that will fit the
+        # data under any rotation.
+        rxs = (rx**2 + ry**2)**0.5
+        rys = (rx**2 + ry**2 + rz**2)**0.5
+
+        self.scale_factor = max(rxs, rys) * 1.04  # 4% extra space
+
+    def viewbox_resize_event(self, event):
+        """The ViewBox resize handler to update the transform
+
+        Parameters
+        ----------
+        event : instance of Event
+            The event.
+        """
+        self.view_changed()
+
+    def _update_transform(self, event=None):
+        # 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
+
+        # Correct for window size
+        w, h = self._viewbox.size
+
+        if (w == 0) or (h == 0):
+            return
+
+        if w / h > 1:
+            fx *= w / h
+        else:
+            fy *= h / w
+
+        self._update_projection_transform(fx, fy)
+
+        # assemble complete transform mapping to viewbox bounds
+        unit = [[-1, 1], [1, -1]]
+        vrect = [[0, 0], self._viewbox.size]
+        self._viewbox_tr.set_mapping(unit, vrect)
+        transforms = [n.transform for n in
+                      self._viewbox.scene.node_path_to_child(self)[1:]]
+        camera_tr = self._transform_cache.get(transforms).inverse
+        full_tr = self._transform_cache.get([self._viewbox_tr,
+                                             self._projection,
+                                             camera_tr])
+        self._transform_cache.roll()
+        self._set_scene_transform(full_tr)
+
+    def _update_projection_transform(self, fx, fy):
+        d = self.depth_value
+        fov = max(0.01, self._fov)
+        dist = fy / (2 * math.tan(math.radians(fov)/2))
+        val = math.sqrt(d)
+        self._projection.set_perspective(fov, fx/fy, dist/val, dist*val)
+
+
+class Base3DRotationCamera(PerspectiveCamera):
+    """Base class for TurntableCamera and ArcballCamera"""
+
+    def __init__(self, fov=0.0, **kwargs):
+        super(Base3DRotationCamera, self).__init__(fov=fov, **kwargs)
+        self._actual_distance = 0.0
+        self._event_value = None
+
+    @property
+    def distance(self):
+        """The user-set distance. If None (default), the distance is
+        internally calculated from the scale factor and fov.
+        """
+        return self._distance
+
+    @distance.setter
+    def distance(self, distance):
+        if distance is None:
+            self._distance = None
+        else:
+            self._distance = float(distance)
+        self.view_changed()
+
+    def viewbox_mouse_event(self, event):
+        """
+        The viewbox received a mouse event; update transform
+        accordingly.
+
+        Parameters
+        ----------
+        event : instance of Event
+            The event.
+        """
+        if event.handled or not self.interactive:
+            return
+
+        PerspectiveCamera.viewbox_mouse_event(self, event)
+
+        if event.type == 'mouse_release':
+            self._event_value = None  # Reset
+        elif event.type == 'mouse_press':
+            event.handled = True
+        elif event.type == 'mouse_move':
+            if event.press_event is None:
+                return
+            if 1 in event.buttons and 2 in event.buttons:
+                return
+
+            modifiers = event.mouse_event.modifiers
+            p1 = event.mouse_event.press_event.pos
+            p2 = event.mouse_event.pos
+            d = p2 - p1
+
+            if 1 in event.buttons and not modifiers:
+                # Rotate
+                self._update_rotation(event)
+
+            elif 2 in event.buttons and not modifiers:
+                # Zoom
+                if self._event_value is None:
+                    self._event_value = (self._scale_factor, self._distance)
+                zoomy = (1 + self.zoom_factor) ** d[1]
+
+                self.scale_factor = self._event_value[0] * zoomy
+                # Modify distance if its given
+                if self._distance is not None:
+                    self._distance = self._event_value[1] * zoomy
+                self.view_changed()
+
+            elif 1 in event.buttons and keys.SHIFT in modifiers:
+                # Translate
+                norm = np.mean(self._viewbox.size)
+                if self._event_value is None or len(self._event_value) == 2:
+                    self._event_value = self.center
+                dist = (p1 - p2) / norm * self._scale_factor
+                dist[1] *= -1
+                # Black magic part 1: turn 2D into 3D translations
+                dx, dy, dz = self._dist_to_trans(dist)
+                # Black magic part 2: take up-vector and flipping into account
+                ff = self._flip_factors
+                up, forward, right = self._get_dim_vectors()
+                dx, dy, dz = right * dx + forward * dy + up * dz
+                dx, dy, dz = ff[0] * dx, ff[1] * dy, dz * ff[2]
+                c = self._event_value
+                self.center = c[0] + dx, c[1] + dy, c[2] + dz
+
+            elif 2 in event.buttons and keys.SHIFT in modifiers:
+                # Change fov
+                if self._event_value is None:
+                    self._event_value = self._fov
+                fov = self._event_value - d[1] / 5.0
+                self.fov = min(180.0, max(0.0, fov))
+
+    def _update_camera_pos(self):
+        """Set the camera position and orientation"""
+        # transform will be updated several times; do not update camera
+        # transform until we are done.
+        ch_em = self.events.transform_change
+        with ch_em.blocker(self._update_transform):
+            up, forward, right = self._get_dim_vectors()
+
+            # Create mapping so correct dim is up
+            pp1 = np.array([(0, 0, 0), (0, 0, -1), (1, 0, 0), (0, 1, 0)])
+            pp2 = np.array([(0, 0, 0), forward, right, up])
+            pos = -self._actual_distance * forward
+            scale = [1.0/a for a in self._flip_factors]
+
+            self.transform.matrix = np.linalg.multi_dot((
+                transforms.affine_map(pp1, pp2).T,
+                transforms.translate(pos),
+                self._get_rotation_tr(),
+                transforms.scale(scale),
+                transforms.translate(self.center)
+            ))
+
+    def _get_dim_vectors(self):
+        # Specify up and forward vector
+        M = {'+z': [(0, 0, +1), (0, 1, 0)],
+             '-z': [(0, 0, -1), (0, 1, 0)],
+             '+y': [(0, +1, 0), (1, 0, 0)],
+             '-y': [(0, -1, 0), (1, 0, 0)],
+             '+x': [(+1, 0, 0), (0, 0, 1)],
+             '-x': [(-1, 0, 0), (0, 0, 1)],
+             }
+        up, forward = M[self.up]
+        right = np.cross(forward, up)
+        return np.array(up), np.array(forward), right
+
+    def _update_projection_transform(self, fx, fy):
+        d = self.depth_value
+        if self._fov == 0:
+            self._projection.set_ortho(-0.5*fx, 0.5*fx, -0.5*fy, 0.5*fy, -d, d)
+            self._actual_distance = self._distance or 0.0
+        else:
+            # Figure distance to center in order to have correct FoV and fy.
+            # Use that auto-distance, or the given distance (if not None).
+            fov = max(0.01, self._fov)
+            dist = fy / (2 * math.tan(math.radians(fov)/2))
+            self._actual_distance = dist = self._distance or dist
+            val = math.sqrt(d*10)
+            self._projection.set_perspective(fov, fx/fy, dist/val, dist*val)
+        # Update camera pos, which will use our calculated _distance to offset
+        # the camera
+        self._update_camera_pos()
+
+    def _update_rotation(self, event):
+        """Update rotation parmeters based on mouse movement"""
+        raise NotImplementedError
+
+    def _rotate_tr(self):
+        """Rotate the transformation matrix based on camera parameters"""
+        raise NotImplementedError
+
+    def _dist_to_trans(self, dist):
+        """Convert mouse x, y movement into x, y, z translations"""
+        raise NotImplementedError

vispy/scene/cameras/tests/test_cameras.py

@@ -0,0 +1,27 @@
+# -*- coding: utf-8 -*-
+# -----------------------------------------------------------------------------
+# Copyright (c) Vispy Development Team. All Rights Reserved.
+# Distributed under the (new) BSD License. See LICENSE.txt for more info.
+# -----------------------------------------------------------------------------
+import numpy as np
+import pytest
+from vispy.scene.cameras import TurntableCamera
+from vispy.testing import run_tests_if_main
+
+
+@pytest.mark.parametrize(
+    "elevation, azimuth, roll, expected",
+    [
+        [0, 0, 0, np.eye(4)],
+        [90, 0, 0, [[1, 0, 0, 0], [0, 0, -1, 0], [0, 1, 0, 0], [0, 0, 0, 1]]],
+        [0, 90, 0, [[0, 1, 0, 0], [-1, 0, 0, 0], [0, 0, 1, 0], [0, 0, 0, 1]]],
+        [0, 0, 90, [[0, 0, -1, 0], [0, 1, 0, 0], [1, 0, 0, 0], [0, 0, 0, 1]]],
+    ],
+)
+def test_turntable_camera_transform(elevation, azimuth, roll, expected):
+    camera = TurntableCamera(elevation=elevation, azimuth=azimuth, roll=roll)
+    matrix = camera._get_rotation_tr()
+    np.testing.assert_allclose(matrix, expected, atol=1e-5)
+
+
+run_tests_if_main()