vispy 0.15.0__cp313-cp313-win_amd64.whl

vispy/util/quaternion.py

@@ -0,0 +1,229 @@
+# -*- coding: utf-8 -*-
+# Copyright (c) Vispy Development Team. All Rights Reserved.
+# Distributed under the (new) BSD License. See LICENSE.txt for more info.
+# Based on the quaternion class in the visvis project.
+
+import numpy as np
+
+
+class Quaternion(object):
+    """Quaternion(w=1, x=0, y=0, z=0, normalize=True)
+
+    A quaternion is a mathematically convenient way to
+    describe rotations.
+
+    """
+
+    def __init__(self, w=1, x=0, y=0, z=0, normalize=True):
+
+        self.w = float(w)
+        self.x, self.y, self.z = float(x), float(y), float(z)
+        if normalize:
+            self._normalize()
+
+    def __repr__(self):
+        return "<Quaternion object %1.3g + %1.3gi + %1.3gj + %1.3gk>" % (
+               self.w, self.x, self.y, self.z)
+
+    def copy(self):
+        """Create an exact copy of this quaternion."""
+        return Quaternion(self.w, self.x, self.y, self.z, False)
+
+    def norm(self):
+        """Returns the norm of the quaternion
+
+        norm = w**2 + x**2 + y**2 + z**2
+        """
+        tmp = self.w**2 + self.x**2 + self.y**2 + self.z**2
+        return tmp**0.5
+
+    def _normalize(self):
+        """Make the quaternion unit length."""
+        # Get length
+        L = self.norm()
+        if not L:
+            raise ValueError('Quaternion cannot have 0-length.')
+        # Correct
+        self.w /= L
+        self.x /= L
+        self.y /= L
+        self.z /= L
+
+    def normalize(self):
+        """Returns a normalized (unit length) version of the quaternion."""
+        new = self.copy()
+        new._normalize()
+        return new
+
+    def conjugate(self):
+        """Obtain the conjugate of the quaternion.
+
+        This is simply the same quaternion but with the sign of the
+        imaginary (vector) parts reversed.
+        """
+        new = self.copy()
+        new.x *= -1
+        new.y *= -1
+        new.z *= -1
+        return new
+
+    def inverse(self):
+        """Returns q.conjugate()/q.norm()**2
+
+        So if the quaternion is unit length, it is the same
+        as the conjugate.
+        """
+        new = self.conjugate()
+        tmp = self.norm()**2
+        new.w /= tmp
+        new.x /= tmp
+        new.y /= tmp
+        new.z /= tmp
+        return new
+
+    def exp(self):
+        """Returns the exponent of the quaternion. 
+        (not tested)
+        """
+        # Init
+        vecNorm = self.x**2 + self.y**2 + self.z**2
+        wPart = np.exp(self.w)        
+        q = Quaternion()
+
+        # Calculate
+        q.w = wPart * np.cos(vecNorm)
+        q.x = wPart * self.x * np.sin(vecNorm) / vecNorm
+        q.y = wPart * self.y * np.sin(vecNorm) / vecNorm
+        q.z = wPart * self.z * np.sin(vecNorm) / vecNorm
+
+        return q
+
+    def log(self):
+        """Returns the natural logarithm of the quaternion. 
+        (not tested)
+        """
+        # Init
+        norm = self.norm()
+        vecNorm = self.x**2 + self.y**2 + self.z**2
+        tmp = self.w / norm
+        q = Quaternion()
+
+        # Calculate
+        q.w = np.log(norm)
+        q.x = np.log(norm) * self.x * np.arccos(tmp) / vecNorm
+        q.y = np.log(norm) * self.y * np.arccos(tmp) / vecNorm
+        q.z = np.log(norm) * self.z * np.arccos(tmp) / vecNorm
+
+        return q
+
+    def __add__(self, q):
+        """Add quaternions."""
+        new = self.copy()
+        new.w += q.w
+        new.x += q.x
+        new.y += q.y
+        new.z += q.z
+        return new
+
+    def __sub__(self, q):
+        """Subtract quaternions."""
+        new = self.copy()
+        new.w -= q.w
+        new.x -= q.x
+        new.y -= q.y
+        new.z -= q.z
+        return new
+
+    def __mul__(self, q2):
+        """Multiply two quaternions."""
+        new = Quaternion()
+        q1 = self       
+        new.w = q1.w*q2.w - q1.x*q2.x - q1.y*q2.y - q1.z*q2.z
+        new.x = q1.w*q2.x + q1.x*q2.w + q1.y*q2.z - q1.z*q2.y
+        new.y = q1.w*q2.y + q1.y*q2.w + q1.z*q2.x - q1.x*q2.z
+        new.z = q1.w*q2.z + q1.z*q2.w + q1.x*q2.y - q1.y*q2.x
+        return new
+
+    def rotate_point(self, p):
+        """Rotate a Point instance using this quaternion."""
+        # Prepare 
+        p = Quaternion(0, p[0], p[1], p[2], False)  # Do not normalize!
+        q1 = self.normalize()
+        q2 = self.inverse()
+        # Apply rotation
+        r = (q1*p)*q2
+        # Make point and return        
+        return r.x, r.y, r.z
+
+    def get_matrix(self):
+        """Create a 4x4 homography matrix that represents the rotation
+        of the quaternion.
+        """
+        # Init matrix (remember, a matrix, not an array)
+        a = np.zeros((4, 4), dtype=np.float32)
+        w, x, y, z = self.w, self.x, self.y, self.z
+        # First row
+        a[0, 0] = - 2.0 * (y * y + z * z) + 1.0
+        a[1, 0] = + 2.0 * (x * y + z * w)
+        a[2, 0] = + 2.0 * (x * z - y * w)
+        a[3, 0] = 0.0
+        # Second row
+        a[0, 1] = + 2.0 * (x * y - z * w)
+        a[1, 1] = - 2.0 * (x * x + z * z) + 1.0
+        a[2, 1] = + 2.0 * (z * y + x * w)
+        a[3, 1] = 0.0
+        # Third row
+        a[0, 2] = + 2.0 * (x * z + y * w)
+        a[1, 2] = + 2.0 * (y * z - x * w)
+        a[2, 2] = - 2.0 * (x * x + y * y) + 1.0
+        a[3, 2] = 0.0
+        # Fourth row
+        a[0, 3] = 0.0
+        a[1, 3] = 0.0
+        a[2, 3] = 0.0
+        a[3, 3] = 1.0
+        return a
+
+    def get_axis_angle(self):
+        """Get the axis-angle representation of the quaternion. 
+        (The angle is in radians)
+        """
+        # Init
+        angle = 2 * np.arccos(max(min(self.w, 1.), -1.))
+        scale = (self.x**2 + self.y**2 + self.z**2)**0.5    
+
+        # Calc axis
+        if scale:
+            ax = self.x / scale
+            ay = self.y / scale
+            az = self.z / scale
+        else:
+            # No rotation, so arbitrary axis
+            ax, ay, az = 1, 0, 0
+        # Return
+        return angle, ax, ay, az
+
+    @classmethod
+    def create_from_axis_angle(cls, angle, ax, ay, az, degrees=False):
+        """Classmethod to create a quaternion from an axis-angle representation. 
+        (angle should be in radians).
+        """
+        if degrees:
+            angle = np.radians(angle)
+        while angle < 0:
+            angle += np.pi*2
+        angle2 = angle/2.0
+        sinang2 = np.sin(angle2)
+        return Quaternion(np.cos(angle2), ax*sinang2, ay*sinang2, az*sinang2)
+
+    @classmethod
+    def create_from_euler_angles(cls, rx, ry, rz, degrees=False):
+        """Classmethod to create a quaternion given the euler angles."""
+        if degrees:
+            rx, ry, rz = np.radians([rx, ry, rz])
+        # Obtain quaternions
+        qx = Quaternion(np.cos(rx/2), 0, 0, np.sin(rx/2))
+        qy = Quaternion(np.cos(ry/2), 0, np.sin(ry/2), 0)
+        qz = Quaternion(np.cos(rz/2), np.sin(rz/2), 0, 0)
+        # Almost done
+        return qx*qy*qz   

vispy/util/svg/__init__.py

@@ -0,0 +1,18 @@
+# -*- coding: utf-8 -*-
+# -----------------------------------------------------------------------------
+# Copyright (c) 2014, Nicolas P. Rougier. All rights reserved.
+# Distributed under the terms of the new BSD License.
+# -----------------------------------------------------------------------------
+from . svg import SVG
+from . path import Path  # noqa
+from . base import namespace
+from xml.etree import ElementTree
+
+
+def Document(filename):
+    tree = ElementTree.parse(filename)
+    root = tree.getroot()
+    if root.tag != namespace + 'svg':
+        text = 'File "%s" does not seem to be a valid SVG file' % filename
+        raise TypeError(text)
+    return SVG(root)

vispy/util/svg/base.py

@@ -0,0 +1,20 @@
+# -*- coding: utf-8 -*-
+# -----------------------------------------------------------------------------
+# Copyright (c) 2014, Nicolas P. Rougier. All rights reserved.
+# Distributed under the terms of the new BSD License.
+# -----------------------------------------------------------------------------
+
+namespace = '{http://www.w3.org/2000/svg}'
+dpi = 90
+units = {
+    None: 1,           # Default unit (same as pixel)
+    'px': 1,           # px: pixel. Default SVG unit
+    'em': 10,          # 1 em = 10 px FIXME
+    'ex': 5,           # 1 ex =  5 px FIXME
+    'in': dpi,          # 1 in = 96 px
+    'cm': dpi / 2.54,   # 1 cm = 1/2.54 in
+    'mm': dpi / 25.4,   # 1 mm = 1/25.4 in
+    'pt': dpi / 72.0,   # 1 pt = 1/72 in
+    'pc': dpi / 6.0,    # 1 pc = 1/6 in
+    '%': 1 / 100.0   # 1 percent
+}

vispy/util/svg/color.py

@@ -0,0 +1,219 @@
+# -*- coding: utf-8 -*-
+# -----------------------------------------------------------------------------
+# Copyright (c) 2014, Nicolas P. Rougier
+# Distributed under the (new) BSD License. See LICENSE.txt for more info.
+# -----------------------------------------------------------------------------
+
+from itertools import product
+from string import hexdigits
+
+
+# See <http://www.w3.org/TR/SVG/types.html#ColorKeywords>
+_keyword_colors = {
+    "aliceblue": (240, 248, 255),
+    "antiquewhite": (250, 235, 215),
+    "aqua": (0, 255, 255),
+    "aquamarine": (127, 255, 212),
+    "azure": (240, 255, 255),
+    "beige": (245, 245, 220),
+    "bisque": (255, 228, 196),
+    "black": (0, 0, 0),
+    "blanchedalmond": (255, 235, 205),
+    "blue": (0, 0, 255),
+    "blueviolet": (138, 43, 226),
+    "brown": (165, 42, 42),
+    "burlywood": (222, 184, 135),
+    "cadetblue": (95, 158, 160),
+    "chartreuse": (127, 255, 0),
+    "chocolate": (210, 105, 30),
+    "coral": (255, 127, 80),
+    "cornflowerblue": (100, 149, 237),
+    "cornsilk": (255, 248, 220),
+    "crimson": (220, 20, 60),
+    "cyan": (0, 255, 255),
+    "darkblue": (0, 0, 139),
+    "darkcyan": (0, 139, 139),
+    "darkgoldenrod": (184, 134, 11),
+    "darkgray": (169, 169, 169),
+    "darkgreen": (0, 100, 0),
+    "darkgrey": (169, 169, 169),
+    "darkkhaki": (189, 183, 107),
+    "darkmagenta": (139, 0, 139),
+    "darkolivegreen": (85, 107, 47),
+    "darkorange": (255, 140, 0),
+    "darkorchid": (153, 50, 204),
+    "darkred": (139, 0, 0),
+    "darksalmon": (233, 150, 122),
+    "darkseagreen": (143, 188, 143),
+    "darkslateblue": (72, 61, 139),
+    "darkslategray": (47, 79, 79),
+    "darkslategrey": (47, 79, 79),
+    "darkturquoise": (0, 206, 209),
+    "darkviolet": (148, 0, 211),
+    "deeppink": (255, 20, 147),
+    "deepskyblue": (0, 191, 255),
+    "dimgray": (105, 105, 105),
+    "dimgrey": (105, 105, 105),
+    "dodgerblue": (30, 144, 255),
+    "firebrick": (178, 34, 34),
+    "floralwhite": (255, 250, 240),
+    "forestgreen": (34, 139, 34),
+    "fuchsia": (255, 0, 255),
+    "gainsboro": (220, 220, 220),
+    "ghostwhite": (248, 248, 255),
+    "gold": (255, 215, 0),
+    "goldenrod": (218, 165, 32),
+    "gray": (128, 128, 128),
+    "grey": (128, 128, 128),
+    "green": (0, 128, 0),
+    "greenyellow": (173, 255, 47),
+    "honeydew": (240, 255, 240),
+    "hotpink": (255, 105, 180),
+    "indianred": (205, 92, 92),
+    "indigo": (75, 0, 130),
+    "ivory": (255, 255, 240),
+    "khaki": (240, 230, 140),
+    "lavender": (230, 230, 250),
+    "lavenderblush": (255, 240, 245),
+    "lawngreen": (124, 252, 0),
+    "lemonchiffon": (255, 250, 205),
+    "lightblue": (173, 216, 230),
+    "lightcoral": (240, 128, 128),
+    "lightcyan": (224, 255, 255),
+    "lightgoldenrodyellow": (250, 250, 210),
+    "lightgray": (211, 211, 211),
+    "lightgreen": (144, 238, 144),
+    "lightgrey": (211, 211, 211),
+    "lightpink": (255, 182, 193),
+    "lightsalmon": (255, 160, 122),
+    "lightseagreen": (32, 178, 170),
+    "lightskyblue": (135, 206, 250),
+    "lightslategray": (119, 136, 153),
+    "lightslategrey": (119, 136, 153),
+    "lightsteelblue": (176, 196, 222),
+    "lightyellow": (255, 255, 224),
+    "lime": (0, 255, 0),
+    "limegreen": (50, 205, 50),
+    "linen": (250, 240, 230),
+    "magenta": (255, 0, 255),
+    "maroon": (128, 0, 0),
+    "mediumaquamarine": (102, 205, 170),
+    "mediumblue": (0, 0, 205),
+    "mediumorchid": (186, 85, 211),
+    "mediumpurple": (147, 112, 219),
+    "mediumseagreen": (60, 179, 113),
+    "mediumslateblue": (123, 104, 238), 
+    "mediumspringgreen": (0, 250, 154),
+    "mediumturquoise": (72, 209, 204),
+    "mediumvioletred": (199, 21, 133),
+    "midnightblue": (25, 25, 112),
+    "mintcream": (245, 255, 250),
+    "mistyrose": (255, 228, 225),
+    "moccasin": (255, 228, 181),
+    "navajowhite": (255, 222, 173),
+    "navy": (0, 0, 128),
+    "oldlace": (253, 245, 230),
+    "olive": (128, 128, 0),
+    "olivedrab": (107, 142, 35),
+    "orange": (255, 165, 0),
+    "orangered": (255, 69, 0),
+    "orchid": (218, 112, 214),
+    "palegoldenrod": (238, 232, 170),
+    "palegreen": (152, 251, 152),
+    "paleturquoise": (175, 238, 238),
+    "palevioletred": (219, 112, 147),
+    "papayawhip": (255, 239, 213),
+    "peachpuff": (255, 218, 185),
+    "peru": (205, 133, 63),
+    "pink": (255, 192, 203),
+    "plum": (221, 160, 221),
+    "powderblue": (176, 224, 230),
+    "purple": (128, 0, 128),
+    "red": (255, 0, 0),
+    "rosybrown": (188, 143, 143),
+    "royalblue": (65, 105, 225),
+    "saddlebrown": (139, 69, 19),
+    "salmon": (250, 128, 114),
+    "sandybrown": (244, 164, 96),
+    "seagreen": (46, 139, 87),
+    "seashell": (255, 245, 238),
+    "sienna": (160, 82, 45),
+    "silver": (192, 192, 192),
+    "skyblue": (135, 206, 235),
+    "slateblue": (106, 90, 205),
+    "slategray": (112, 128, 144),
+    "slategrey": (112, 128, 144),
+    "snow": (255, 250, 250),
+    "springgreen": (0, 255, 127),
+    "steelblue": (70, 130, 180),
+    "tan": (210, 180, 140),
+    "teal": (0, 128, 128),
+    "thistle": (216, 191, 216),
+    "tomato": (255, 99, 71),
+    "turquoise": (64, 224, 208),
+    "violet": (238, 130, 238),
+    "wheat": (245, 222, 179),
+    "white": (255, 255, 255),
+    "whitesmoke": (245, 245, 245),
+    "yellow": (255, 255, 0),
+    "yellowgreen": (154, 205, 50)}
+
+
+_HEXDEC = {}
+for x, y in product(hexdigits, repeat=2):
+    v = x + y
+    _HEXDEC[v] = int(v, 16)
+
+
+def _rgb(triplet):
+    return _HEXDEC[triplet[0:2]], _HEXDEC[triplet[2:4]], _HEXDEC[triplet[4:6]]
+
+
+class Color(object):
+
+    def __init__(self, content):
+
+        color = content.strip()
+        if color.startswith("#"):
+            rgb = color[1:]
+            if len(rgb) == 3:
+                r, g, b = tuple(ord((c + c).decode('hex')) for c in rgb)
+            else:
+                # r,g,b = tuple(ord(c) for c in rgb.decode('hex'))
+                r, g, b = tuple(c for c in _rgb(rgb))
+        elif color.startswith("rgb("):
+            rgb = color[4:-1]
+            r, g, b = [value.strip() for value in rgb.split(',')]
+            if r.endswith("%"):
+                r = 255 * int(r[:-1]) // 100
+            else:
+                r = int(r)
+            if g.endswith("%"):
+                g = 255 * int(g[:-1]) // 100
+            else:
+                g = int(r)
+            if b.endswith("%"):
+                b = 255 * int(b[:-1]) // 100
+            else:
+                b = int(r)
+        elif color in _keyword_colors:
+            r, g, b = _keyword_colors[color]
+        else:
+            # text = "Unknown color (%s)" % color
+            r, g, b = 0, 0, 0
+        self._rgb = r / 255., g / 255., b / 255.
+
+    @property
+    def rgb(self):
+        r, g, b = self._rgb
+        return r, g, b
+
+    @property
+    def rgba(self):
+        r, g, b = self._rgb
+        return r, g, b, 1
+
+    def __repr__(self):
+        r, g, b = self._rgb
+        r, g, b = int(r * 255), int(g * 255), int(b * 255)
+        return "#%02x%02x%02x" % (r, g, b)

vispy/util/svg/element.py

@@ -0,0 +1,51 @@
+# -*- coding: utf-8 -*-
+# -----------------------------------------------------------------------------
+# Copyright (c) 2014, Nicolas P. Rougier. All rights reserved.
+# Distributed under the terms of the new BSD License.
+# -----------------------------------------------------------------------------
+import copy
+from . style import Style
+
+namespace = '{http://www.w3.org/2000/svg}'
+
+
+class Element(object):
+    """Generic SVG element"""
+
+    def __init__(self, content=None, parent=None):
+        self._parent = parent
+        self._id = hex(id(self))
+        self._style = Style()
+        self._computed_style = Style()
+
+        if isinstance(content, str):
+            return
+
+        self._id = content.get('id', self._id)
+        self._style.update(content.get("style", None))
+        self._computed_style = Style()
+        if parent and parent.style:
+            self._computed_style = copy.copy(parent.style)
+            self._computed_style.update(content.get("style", None))
+
+    @property
+    def root(self):
+        if self._parent:
+            return self._parent.root
+        return self
+
+    @property
+    def parent(self):
+        if self._parent:
+            return self._parent
+        return None
+
+    @property
+    def style(self):
+        return self._computed_style
+
+    @property
+    def viewport(self):
+        if self._parent:
+            return self._parent.viewport
+        return None