vispy 0.15.0__cp312-cp312-macosx_10_13_x86_64.whl

vispy/visuals/transforms/linear.py

@@ -0,0 +1,564 @@
+# -*- 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 ...util import transforms
+from ...geometry import Rect
+from ._util import arg_to_vec4, as_vec4
+from .base_transform import BaseTransform
+
+
+class NullTransform(BaseTransform):
+    """Transform having no effect on coordinates (identity transform)."""
+
+    glsl_map = "vec4 null_transform_map(vec4 pos) {return pos;}"
+    glsl_imap = "vec4 null_transform_imap(vec4 pos) {return pos;}"
+
+    Linear = True
+    Orthogonal = True
+    NonScaling = True
+    Isometric = True
+
+    @arg_to_vec4
+    def map(self, coords):
+        """Map coordinates
+
+        Parameters
+        ----------
+        coords : array-like
+            Coordinates to map.
+        """
+        return coords
+
+    def imap(self, coords):
+        """Inverse map coordinates
+
+        Parameters
+        ----------
+        coords : array-like
+            Coordinates to inverse map.
+        """
+        return coords
+
+    def __mul__(self, tr):
+        return tr
+
+    def __rmul__(self, tr):
+        return tr
+
+
+class STTransform(BaseTransform):
+    """Transform performing only scale and translate, in that order.
+
+    Parameters
+    ----------
+    scale : array-like
+        Scale factors for X, Y, Z axes.
+    translate : array-like
+        Scale factors for X, Y, Z axes.
+    """
+
+    glsl_map = """
+        vec4 st_transform_map(vec4 pos) {
+            return vec4(pos.xyz * $scale.xyz + $translate.xyz * pos.w, pos.w);
+        }
+    """
+
+    glsl_imap = """
+        vec4 st_transform_imap(vec4 pos) {
+            return vec4((pos.xyz - $translate.xyz * pos.w) / $scale.xyz,
+                        pos.w);
+        }
+    """
+
+    Linear = True
+    Orthogonal = True
+    NonScaling = False
+    Isometric = False
+
+    def __init__(self, scale=None, translate=None):
+        super(STTransform, self).__init__()
+
+        self._scale = np.ones(4, dtype=np.float32)
+        self._translate = np.zeros(4, dtype=np.float32)
+
+        s = ((1.0, 1.0, 1.0, 1.0) if scale is None else
+             as_vec4(scale, default=(1., 1., 1., 1.)))
+        t = ((0.0, 0.0, 0.0, 0.0) if translate is None else
+             as_vec4(translate, default=(0., 0., 0., 0.)))
+        self._set_st(s, t)
+        self._update_shaders()
+
+    @arg_to_vec4
+    def map(self, coords):
+        """Map coordinates
+
+        Parameters
+        ----------
+        coords : array-like
+            Coordinates to map.
+
+        Returns
+        -------
+        coords : ndarray
+            Coordinates.
+        """
+        m = np.empty(coords.shape)
+        m[:, :3] = (coords[:, :3] * self.scale[np.newaxis, :3] +
+                    coords[:, 3:] * self.translate[np.newaxis, :3])
+        m[:, 3] = coords[:, 3]
+        return m
+
+    @arg_to_vec4
+    def imap(self, coords):
+        """Invert map coordinates
+
+        Parameters
+        ----------
+        coords : array-like
+            Coordinates to inverse map.
+
+        Returns
+        -------
+        coords : ndarray
+            Coordinates.
+        """
+        m = np.empty(coords.shape)
+        m[:, :3] = ((coords[:, :3] -
+                     coords[:, 3:] * self.translate[np.newaxis, :3]) /
+                    self.scale[np.newaxis, :3])
+        m[:, 3] = coords[:, 3]
+        return m
+
+    def shader_map(self):
+        return self._shader_map
+
+    def shader_imap(self):
+        return self._shader_imap
+
+    @property
+    def scale(self):
+        return self._scale.copy()
+
+    @scale.setter
+    def scale(self, s):
+        s = as_vec4(s, default=(1, 1, 1, 1))
+        self._set_st(scale=s)
+
+    @property
+    def translate(self):
+        return self._translate.copy()
+
+    @translate.setter
+    def translate(self, t):
+        t = as_vec4(t, default=(0, 0, 0, 0))
+        self._set_st(translate=t)
+
+    def _set_st(self, scale=None, translate=None, update=True):
+        need_update = False
+
+        if scale is not None and not np.all(scale == self._scale):
+            self._scale[:] = scale
+            need_update = True
+
+        if translate is not None and not np.all(translate == self._translate):
+            self._translate[:] = translate
+            need_update = True
+
+        if update and need_update:
+            self._update_shaders()
+            self.update()   # inform listeners there has been a change
+
+    def _update_shaders(self):
+        self._shader_map['scale'] = self.scale
+        self._shader_map['translate'] = self.translate
+        self._shader_imap['scale'] = self.scale
+        self._shader_imap['translate'] = self.translate
+
+    def move(self, move):
+        """Change the translation of this transform by the amount given.
+
+        Parameters
+        ----------
+        move : array-like
+            The values to be added to the current translation of the transform.
+        """
+        move = as_vec4(move, default=(0, 0, 0, 0))
+        self.translate = self.translate + move
+
+    def zoom(self, zoom, center=(0, 0, 0), mapped=True):
+        """Update the transform such that its scale factor is changed, but
+        the specified center point is left unchanged.
+
+        Parameters
+        ----------
+        zoom : array-like
+            Values to multiply the transform's current scale
+            factors.
+        center : array-like
+            The center point around which the scaling will take place.
+        mapped : bool
+            Whether *center* is expressed in mapped coordinates (True) or
+            unmapped coordinates (False).
+        """
+        zoom = as_vec4(zoom, default=(1, 1, 1, 1))
+        center = as_vec4(center, default=(0, 0, 0, 0))
+        scale = self.scale * zoom
+        if mapped:
+            trans = center - (center - self.translate) * zoom
+        else:
+            trans = self.scale * (1 - zoom) * center + self.translate
+        self._set_st(scale=scale, translate=trans)
+
+    def as_matrix(self):
+        m = MatrixTransform()
+        m.scale(self.scale)
+        m.translate(self.translate)
+        return m
+
+    @classmethod
+    def from_mapping(cls, x0, x1):
+        """Create an STTransform from the given mapping
+
+        See `set_mapping` for details.
+
+        Parameters
+        ----------
+        x0 : array-like
+            Start.
+        x1 : array-like
+            End.
+
+        Returns
+        -------
+        t : instance of STTransform
+            The transform.
+        """
+        t = cls()
+        t.set_mapping(x0, x1)
+        return t
+
+    def set_mapping(self, x0, x1, update=True):
+        """Configure this transform such that it maps points x0 => x1
+
+        Parameters
+        ----------
+        x0 : array-like, shape (2, 2) or (2, 3)
+            Start location.
+        x1 : array-like, shape (2, 2) or (2, 3)
+            End location.
+        update : bool
+            If False, then the update event is not emitted.
+
+        Examples
+        --------
+        For example, if we wish to map the corners of a rectangle::
+
+            >>> p1 = [[0, 0], [200, 300]]
+
+        onto a unit cube::
+
+            >>> p2 = [[-1, -1], [1, 1]]
+
+        then we can generate the transform as follows::
+
+            >>> tr = STTransform()
+            >>> tr.set_mapping(p1, p2)
+            >>> assert tr.map(p1)[:,:2] == p2  # test
+        """
+        # if args are Rect, convert to array first
+        if isinstance(x0, Rect):
+            x0 = x0._transform_in()[:3]
+        if isinstance(x1, Rect):
+            x1 = x1._transform_in()[:3]
+
+        x0 = np.asarray(x0)
+        x1 = np.asarray(x1)
+        if (x0.ndim != 2 or x0.shape[0] != 2 or x1.ndim != 2 or
+                x1.shape[0] != 2):
+            raise TypeError("set_mapping requires array inputs of shape "
+                            "(2, N).")
+        denom = x0[1] - x0[0]
+        mask = denom == 0
+        denom[mask] = 1.0
+        s = (x1[1] - x1[0]) / denom
+        s[mask] = 1.0
+        s[x0[1] == x0[0]] = 1.0
+        t = x1[0] - s * x0[0]
+        s = as_vec4(s, default=(1, 1, 1, 1))
+        t = as_vec4(t, default=(0, 0, 0, 0))
+        self._set_st(scale=s, translate=t, update=update)
+
+    def __mul__(self, tr):
+        if isinstance(tr, STTransform):
+            s = self.scale * tr.scale
+            t = self.translate + (tr.translate * self.scale)
+            return STTransform(scale=s, translate=t)
+        elif isinstance(tr, MatrixTransform):
+            return self.as_matrix() * tr
+        else:
+            return super(STTransform, self).__mul__(tr)
+
+    def __rmul__(self, tr):
+        if isinstance(tr, MatrixTransform):
+            return tr * self.as_matrix()
+        return super(STTransform, self).__rmul__(tr)
+
+    def __repr__(self):
+        return ("<STTransform scale=%s translate=%s at 0x%s>"
+                % (self.scale, self.translate, id(self)))
+
+
+class MatrixTransform(BaseTransform):
+    """Affine transformation class
+
+    Parameters
+    ----------
+    matrix : array-like | None
+        4x4 array to use for the transform.
+    """
+
+    glsl_map = """
+        vec4 affine_transform_map(vec4 pos) {
+            return $matrix * pos;
+        }
+    """
+
+    glsl_imap = """
+        vec4 affine_transform_imap(vec4 pos) {
+            return $inv_matrix * pos;
+        }
+    """
+
+    Linear = True
+    Orthogonal = False
+    NonScaling = False
+    Isometric = False
+
+    def __init__(self, matrix=None):
+        super(MatrixTransform, self).__init__()
+        if matrix is not None:
+            self.matrix = matrix
+        else:
+            self.reset()
+
+    @arg_to_vec4
+    def map(self, coords):
+        """Map coordinates
+
+        Parameters
+        ----------
+        coords : array-like
+            Coordinates to map.
+
+        Returns
+        -------
+        coords : ndarray
+            Coordinates.
+        """
+        # looks backwards, but both matrices are transposed.
+        return np.dot(coords, self.matrix)
+
+    @arg_to_vec4
+    def imap(self, coords):
+        """Inverse map coordinates
+
+        Parameters
+        ----------
+        coords : array-like
+            Coordinates to inverse map.
+
+        Returns
+        -------
+        coords : ndarray
+            Coordinates.
+        """
+        return np.dot(coords, self.inv_matrix)
+
+    def shader_map(self):
+        fn = super(MatrixTransform, self).shader_map()
+        fn['matrix'] = self.matrix  # uniform mat4
+        return fn
+
+    def shader_imap(self):
+        fn = super(MatrixTransform, self).shader_imap()
+        fn['inv_matrix'] = self.inv_matrix  # uniform mat4
+        return fn
+
+    @property
+    def matrix(self):
+        return self._matrix
+
+    @matrix.setter
+    def matrix(self, m):
+        self._matrix = m
+        self._inv_matrix = None
+        self.shader_map()
+        self.shader_imap()
+        self.update()
+
+    @property
+    def inv_matrix(self):
+        if self._inv_matrix is None:
+            self._inv_matrix = np.linalg.inv(self.matrix)
+        return self._inv_matrix
+
+    @arg_to_vec4
+    def translate(self, pos):
+        """
+        Translate the matrix
+
+        The translation is applied *after* the transformations already present
+        in the matrix.
+
+        Parameters
+        ----------
+        pos : arrayndarray
+            Position to translate by.
+        """
+        self.matrix = np.dot(self.matrix, transforms.translate(pos[0, :3]))
+
+    def scale(self, scale, center=None):
+        """
+        Scale the matrix about a given origin.
+
+        The scaling is applied *after* the transformations already present
+        in the matrix.
+
+        Parameters
+        ----------
+        scale : array-like
+            Scale factors along x, y and z axes.
+        center : array-like or None
+            The x, y and z coordinates to scale around. If None,
+            (0, 0, 0) will be used.
+        """
+        scale = transforms.scale(as_vec4(scale, default=(1, 1, 1, 1))[0, :3])
+        if center is not None:
+            center = as_vec4(center)[0, :3]
+            scale = np.dot(np.dot(transforms.translate(-center), scale),
+                           transforms.translate(center))
+        self.matrix = np.dot(self.matrix, scale)
+
+    def rotate(self, angle, axis):
+        """
+        Rotate the matrix by some angle about a given axis.
+
+        The rotation is applied *after* the transformations already present
+        in the matrix.
+
+        Parameters
+        ----------
+        angle : float
+            The angle of rotation, in degrees.
+        axis : array-like
+            The x, y and z coordinates of the axis vector to rotate around.
+        """
+        self.matrix = np.dot(self.matrix, transforms.rotate(angle, axis))
+
+    def set_mapping(self, points1, points2):
+        """Set to a 3D transformation matrix that maps points1 onto points2.
+
+        Parameters
+        ----------
+        points1 : array-like, shape (4, 3)
+            Four starting 3D coordinates.
+        points2 : array-like, shape (4, 3)
+            Four ending 3D coordinates.
+        """
+        # note: need to transpose because util.functions uses opposite
+        # of standard linear algebra order.
+        self.matrix = transforms.affine_map(points1, points2).T
+
+    def set_ortho(self, l, r, b, t, n, f):  # noqa
+        """Set ortho transform
+
+        Parameters
+        ----------
+        l : float
+            Left.
+        r : float
+            Right.
+        b : float
+            Bottom.
+        t : float
+            Top.
+        n : float
+            Near.
+        f : float
+            Far.
+        """
+        self.matrix = transforms.ortho(l, r, b, t, n, f)
+
+    def reset(self):
+        self.matrix = np.eye(4)
+
+    def __mul__(self, tr):
+        if (isinstance(tr, MatrixTransform) and not
+                any(tr.matrix[:3, 3] != 0)):
+            # don't multiply if the perspective column is used
+            return MatrixTransform(matrix=np.dot(tr.matrix, self.matrix))
+        else:
+            return tr.__rmul__(self)
+
+    def __repr__(self):
+        s = "%s(matrix=[" % self.__class__.__name__
+        indent = " "*len(s)
+        s += str(list(self.matrix[0])) + ",\n"
+        s += indent + str(list(self.matrix[1])) + ",\n"
+        s += indent + str(list(self.matrix[2])) + ",\n"
+        s += indent + str(list(self.matrix[3])) + "] at 0x%x)" % id(self)
+        return s
+
+    def set_perspective(self, fov, aspect, near, far):
+        """Set the perspective
+
+        Parameters
+        ----------
+        fov : float
+            Field of view.
+        aspect : float
+            Aspect ratio.
+        near : float
+            Near location.
+        far : float
+            Far location.
+        """
+        self.matrix = transforms.perspective(fov, aspect, near, far)
+
+    def set_frustum(self, l, r, b, t, n, f):  # noqa
+        """Set the frustum
+
+        Parameters
+        ----------
+        l : float
+            Left.
+        r : float
+            Right.
+        b : float
+            Bottom.
+        t : float
+            Top.
+        n : float
+            Near.
+        f : float
+            Far.
+        """
+        self.matrix = transforms.frustum(l, r, b, t, n, f)
+
+
+# class SRTTransform(BaseTransform):
+#    """ Transform performing scale, rotate, and translate, in that order.
+#
+#    This transformation allows objects to be placed arbitrarily in a scene
+#    much the same way MatrixTransform does. However, an incorrect order of
+#    operations in MatrixTransform may result in shearing the object (if scale
+#    is applied after rotate) or in unpredictable translation (if scale/rotate
+#    is applied after translation). SRTTransform avoids these problems by
+#    enforcing the correct order of operations.
+#    """
+#    # TODO