vispy 0.15.0__cp313-cp313-win_amd64.whl

vispy/util/svg/path.py

@@ -0,0 +1,332 @@
+# -*- coding: utf-8 -*-
+# -----------------------------------------------------------------------------
+# Copyright (c) 2014, Nicolas P. Rougier
+# Distributed under the (new) BSD License. See LICENSE.txt for more info.
+# -----------------------------------------------------------------------------
+import re
+import math
+import numpy as np
+
+from . import geometry
+from . geometry import epsilon
+from . transformable import Transformable
+
+
+# ----------------------------------------------------------------- Command ---
+class Command(object):
+
+    def __repr__(self):
+        s = '%s ' % self._command
+        for arg in self._args:
+            s += "%.2f " % arg
+        return s
+
+    def origin(self, current=None, previous=None):
+        relative = self._command in "mlvhcsqtaz"
+
+        if relative and current:
+            return current
+        else:
+            return 0.0, 0.0
+
+
+# -------------------------------------------------------------------- Line ---
+class Line(Command):
+
+    def __init__(self, x=0, y=0, relative=True):
+        self._command = 'l' if relative else 'L'
+        self._args = [x, y]
+
+    def vertices(self, current, previous=None):
+        ox, oy = self.origin(current)
+        x, y = self._args
+        self.previous = x, y
+
+        return (ox + x, oy + y),
+
+
+# ------------------------------------------------------------------- VLine ---
+class VLine(Command):
+
+    def __init__(self, y=0, relative=True):
+        self._command = 'v' if relative else 'V'
+        self._args = [y]
+
+    def vertices(self, current, previous=None):
+        ox, oy = self.origin(current)
+        y = self._args[0]
+        self.previous = ox, oy + y
+
+        return (ox, oy + y),
+
+
+# ------------------------------------------------------------------- HLine ---
+class HLine(Command):
+
+    def __init__(self, x=0, relative=True):
+        self._command = 'h' if relative else 'H'
+        self._args = [x]
+
+    def vertices(self, current, previous=None):
+        ox, oy = self.origin(current)
+        x = self._args[0]
+        self.previous = ox + x, oy
+
+        return (ox + x, oy),
+
+
+# -------------------------------------------------------------------- Move ---
+class Move(Command):
+
+    def __init__(self, x=0, y=0, relative=True):
+        self._command = 'm' if relative else 'M'
+        self._args = [x, y]
+
+    def vertices(self, current, previous=None):
+        ox, oy = self.origin(current)
+        x, y = self._args
+        x, y = x + ox, y + oy
+        self.previous = x, y
+        return (x, y),
+
+
+# ------------------------------------------------------------------- Close ---
+class Close(Command):
+
+    def __init__(self, relative=True):
+        self._command = 'z' if relative else 'Z'
+        self._args = []
+
+    def vertices(self, current, previous=None):
+        self.previous = current
+        return []
+
+
+# --------------------------------------------------------------------- Arc ---
+class Arc(Command):
+
+    def __init__(self, r1=1, r2=1, angle=2 * math.pi, large=True, sweep=True,
+                 x=0, y=0, relative=True):
+        self._command = 'a' if relative else 'A'
+        self._args = [r1, r2, angle, large, sweep, x, y]
+
+    def vertices(self, current, previous=None):
+        ox, oy = self.origin(current)
+        rx, ry, angle, large, sweep, x, y = self._args
+        x, y = x + ox, y + oy
+        x0, y0 = current
+        self.previous = x, y
+        vertices = geometry.elliptical_arc(
+            x0, y0, rx, ry, angle, large, sweep, x, y)
+        return vertices[1:]
+
+
+# ------------------------------------------------------------------- Cubic ---
+class Cubic(Command):
+
+    def __init__(self, x1=0, y1=0, x2=0, y2=0, x3=0, y3=0, relative=True):
+        self._command = 'c' if relative else 'C'
+        self._args = [x1, y1, x2, y2, x3, y3]
+
+    def vertices(self, current, previous=None):
+        ox, oy = self.origin(current)
+        x0, y0 = current
+        x1, y1, x2, y2, x3, y3 = self._args
+        x1, y1 = x1 + ox, y1 + oy
+        x2, y2 = x2 + ox, y2 + oy
+        x3, y3 = x3 + ox, y3 + oy
+        self.previous = x2, y2
+        vertices = geometry.cubic((x0, y0), (x1, y1), (x2, y2), (x3, y3))
+        return vertices[1:]
+
+
+# --------------------------------------------------------------- Quadratic ---
+class Quadratic(Command):
+
+    def __init__(self, x1=0, y1=0, x2=0, y2=0, relative=True):
+        self._command = 'q' if relative else 'Q'
+        self._args = [x1, y1, x2, y2]
+
+    def vertices(self, current, last_control_point=None):
+        ox, oy = self.origin(current)
+        x1, y1, x2, y2 = self._args
+        x0, y0 = current
+        x1, y1 = x1 + ox, y1 + oy
+        x2, y2 = x2 + ox, y2 + oy
+        self.previous = x1, y1
+        vertices = geometry.quadratic((x0, y0), (x1, y1), (x2, y2))
+
+        return vertices[1:]
+
+
+# ------------------------------------------------------------- SmoothCubic ---
+class SmoothCubic(Command):
+
+    def __init__(self, x2=0, y2=0, x3=0, y3=0, relative=True):
+        self._command = 's' if relative else 'S'
+        self._args = [x2, y2, x3, y3]
+
+    def vertices(self, current, previous):
+        ox, oy = self.origin(current)
+        x0, y0 = current
+        x2, y2, x3, y3 = self._args
+        x2, y2 = x2 + ox, y2 + oy
+        x3, y3 = x3 + ox, y3 + oy
+        x1, y1 = 2 * x0 - previous[0], 2 * y0 - previous[1]
+        self.previous = x2, y2
+        vertices = geometry.cubic((x0, y0), (x1, y1), (x2, y2), (x3, y3))
+
+        return vertices[1:]
+
+
+# --------------------------------------------------------- SmoothQuadratic ---
+class SmoothQuadratic(Command):
+
+    def __init__(self, x2=0, y2=0, relative=True):
+        self._command = 't' if relative else 'T'
+        self._args = [x2, y2]
+
+    def vertices(self, current, previous):
+        ox, oy = self.origin(current)
+        x2, y2 = self._args
+        x0, y0 = current
+        x1, y1 = 2 * x0 - previous[0], 2 * y0 - previous[1]
+        x2, y2 = x2 + ox, y2 + oy
+        self.previous = x1, y1
+        vertices = geometry.quadratic((x0, y0), (x1, y1), (x2, y2))
+
+        return vertices[1:]
+
+
+# -------------------------------------------------------------------- Path ---
+class Path(Transformable):
+
+    def __init__(self, content=None, parent=None):
+        Transformable.__init__(self, content, parent)
+        self._paths = []
+
+        if not isinstance(content, str):
+            content = content.get("d", "")
+
+        commands = re.compile(
+            r"(?P<command>[MLVHCSQTAZmlvhcsqtaz])"
+            r"(?P<points>[+\-0-9.e, \n\t]*)")
+
+        path = []
+        for match in re.finditer(commands, content):
+            command = match.group("command")
+            points = match.group("points").replace(',', ' ')
+            points = [float(v) for v in points.split()]
+            relative = command in "mlvhcsqtaz"
+            command = command.upper()
+
+            while len(points) or command == 'Z':
+                if command == 'M':
+                    if len(path):
+                        self._paths.append(path)
+                    path = []
+                    path.append(Move(*points[:2], relative=relative))
+                    points = points[2:]
+                elif command == 'L':
+                    path.append(Line(*points[:2], relative=relative))
+                    points = points[2:]
+                elif command == 'V':
+                    path.append(VLine(*points[:1], relative=relative))
+                    points = points[1:]
+                elif command == 'H':
+                    path.append(HLine(*points[:1], relative=relative))
+                    points = points[1:]
+                elif command == 'C':
+                    path.append(Cubic(*points[:6], relative=relative))
+                    points = points[6:]
+                elif command == 'S':
+                    path.append(SmoothCubic(*points[:4], relative=relative))
+                    points = points[4:]
+                elif command == 'Q':
+                    path.append(Quadratic(*points[:4], relative=relative))
+                    points = points[4:]
+                elif command == 'T':
+                    path.append(
+                        SmoothQuadratic(*points[2:], relative=relative))
+                    points = points[2:]
+                elif command == 'A':
+                    path.append(Arc(*points[:7], relative=relative))
+                    points = points[7:]
+                elif command == 'Z':
+                    path.append(Close(relative=relative))
+                    self._paths.append(path)
+                    path = []
+                    break
+                else:
+                    raise RuntimeError(
+                        "Unknown SVG path command(%s)" % command)
+
+        if len(path):
+            self._paths.append(path)
+
+    def __repr__(self):
+        s = ""
+        for path in self._paths:
+            for item in path:
+                s += repr(item)
+        return s
+
+    @property
+    def xml(self):
+        return self._xml()
+
+    def _xml(self, prefix=""):
+        s = prefix + "<path "
+        s += 'id="%s" ' % self._id
+        s += self._style.xml
+        s += '\n'
+        t = '     ' + prefix + ' d="'
+        s += t
+        prefix = ' ' * len(t)
+        first = True
+        for i, path in enumerate(self._paths):
+            for j, item in enumerate(path):
+                if first:
+                    s += repr(item)
+                    first = False
+                else:
+                    s += prefix + repr(item)
+                if i < len(self._paths) - 1 or j < len(path) - 1:
+                    s += '\n'
+        s += '"/>\n'
+        return s
+
+    @property
+    def vertices(self):
+        self._vertices = []
+        current = 0, 0
+        previous = 0, 0
+
+        for path in self._paths:
+            vertices = []
+            for command in path:
+                V = command.vertices(current, previous)
+                previous = command.previous
+                vertices.extend(V)
+                if len(V) > 0:
+                    current = V[-1]
+                else:
+                    current = 0, 0
+
+            closed = False
+            if isinstance(command, Close):
+                closed = True
+                if len(vertices) > 2:
+                    d = geometry.calc_sq_distance(vertices[-1][0], vertices[-1][1],  # noqa
+                                                  vertices[0][0], vertices[0][1])  # noqa
+                    if d < epsilon:
+                        vertices = vertices[:-1]
+
+            # Apply transformation
+            V = np.ones((len(vertices), 3))
+            V[:, :2] = vertices
+            V = np.dot(V, self.transform.matrix.T)
+            V[:, 2] = 0
+            self._vertices.append((V, closed))
+
+        return self._vertices

vispy/util/svg/shapes.py

@@ -0,0 +1,57 @@
+# -*- coding: utf-8 -*-
+# -----------------------------------------------------------------------------
+# Copyright (c) 2014, Nicolas P. Rougier
+# Distributed under the (new) BSD License. See LICENSE.txt for more info.
+# -----------------------------------------------------------------------------
+
+
+class Rect(object):
+
+    def __init__(self, x=0, y=0, width=1, height=1, rx=0, ry=0):
+        self.x = x
+        self.y = y
+        self.width = width
+        self.height = height
+        self.rx = rx
+        self.ry = ry
+
+    def parse(self, expression):
+        """ """
+
+
+class Line(object):
+
+    def __init__(self, x1=0, y1=0, x2=0, y2=0):
+        self.x1 = x2
+        self.y1 = y2
+        self.x2 = x2
+        self.y2 = y2
+
+
+class Circle(object):
+
+    def __init__(self, cx=0, cy=0, r=1):
+        self.cx = cx
+        self.cy = cy
+        self.r = r
+
+
+class Ellipse(object):
+
+    def __init__(self, cx=0, cy=0, rx=1, ry=1):
+        self.cx = cx
+        self.cy = cy
+        self.rx = rx
+        self.ry = ry
+
+
+class Polygon(object):
+
+    def __init__(self, points=[]):
+        self.points = points
+
+
+class Polyline(object):
+
+    def __init__(self, points=[]):
+        self.points = points

vispy/util/svg/style.py

@@ -0,0 +1,59 @@
+# -*- coding: utf-8 -*-
+# -----------------------------------------------------------------------------
+# Copyright (c) 2014, Nicolas P. Rougier
+# Distributed under the (new) BSD License. See LICENSE.txt for more info.
+# -----------------------------------------------------------------------------
+
+from . color import Color
+from . number import Number
+from . length import Length
+
+_converters = {
+    "fill": Color,
+    "fill-opacity": Number,
+    "stroke": Color,
+    "stroke-opacity": Number,
+    "opacity": Number,
+    "stroke-width": Length,
+    #    "stroke-miterlimit": Number,
+    #    "stroke-dasharray":  Lengths,
+    #    "stroke-dashoffset": Length,
+}
+
+
+class Style(object):
+
+    def __init__(self):
+        self._unset = True
+        for key in _converters.keys():
+            key_ = key.replace("-", "_")
+            self.__setattr__(key_, None)
+
+    def update(self, content):
+        if not content:
+            return
+
+        self._unset = False
+        items = content.strip().split(";")
+        attributes = dict([item.strip().split(":") for item in items if item])
+        for key, value in attributes.items():
+            if key in _converters:
+                key_ = key.replace("-", "_")
+                self.__setattr__(key_, _converters[key](value))
+
+    @property
+    def xml(self):
+        return self._xml()
+
+    def _xml(self, prefix=""):
+        if self._unset:
+            return ""
+
+        s = 'style="'
+        for key in _converters.keys():
+            key_ = key.replace("-", "_")
+            value = self.__getattribute__(key_)
+            if value is not None:
+                s += '%s:%s ' % (key, value)
+        s += '"'
+        return s

vispy/util/svg/svg.py

@@ -0,0 +1,40 @@
+# -*- coding: utf-8 -*-
+# -----------------------------------------------------------------------------
+# Copyright (c) 2014, Nicolas P. Rougier. All rights reserved.
+# Distributed under the terms of the new BSD License.
+# -----------------------------------------------------------------------------
+
+from . group import Group
+from . viewport import Viewport
+
+
+class SVG(Group):
+
+    def __init__(self, content=None, parent=None):
+        Group.__init__(self, content, parent)
+        self._viewport = Viewport(content)
+
+    @property
+    def viewport(self):
+        return self._viewport
+
+    def __repr__(self):
+        s = ""
+        for item in self._items:
+            s += repr(item) + "\n"
+        return s
+
+    @property
+    def xml(self):
+        return self._xml()
+
+    def _xml(self, prefix=""):
+        s = "<svg "
+        s += 'id="%s" ' % self._id
+        s += self._viewport.xml
+        s += self._transform.xml
+        s += "\n"
+        for item in self._items:
+            s += item._xml(prefix=prefix + "    ") + "\n"
+        s += "</svg>\n"
+        return s

vispy/util/svg/transform.py

@@ -0,0 +1,223 @@
+# -*- coding: utf-8 -*-
+# -----------------------------------------------------------------------------
+# Copyright (c) 2014, Nicolas P. Rougier. All rights reserved.
+# Distributed under the terms of the new BSD License.
+# -----------------------------------------------------------------------------
+import re
+import math
+import numpy as np
+
+# ------------------------------------------------------------------ Matrix ---
+
+
+class Matrix(object):
+
+    def __init__(self, a=1, b=0, c=0, d=1, e=0, f=0):
+        self._matrix = np.array([[a, c, e],
+                                 [b, d, f],
+                                 [0, 0, 1]], dtype=float)
+
+    @property
+    def matrix(self):
+        return self._matrix
+
+    def __array__(self, *args):
+        return self._matrix
+
+    def __repr__(self):
+        a, c, e = self._matrix[0]
+        b, d, f = self._matrix[1]
+        return "Matrix(%g,%g,%g,%g,%g,%g)" % (a, b, c, d, e, f)
+
+
+# ---------------------------------------------------------------- Identity ---
+class Identity(Matrix):
+
+    def __init__(self):
+        Matrix.__init__(self)
+        self._matrix[...] = ([[1, 0, 0],
+                              [0, 1, 0],
+                              [0, 0, 1]])
+
+    def __repr__(self):
+        return "Identity()"
+
+
+# --------------------------------------------------------------- Translate ---
+class Translate(Matrix):
+    """
+    Translation is equivalent to the matrix [1 0 0 1 tx ty], where tx and ty
+    are the distances to translate coordinates in X and Y, respectively.
+    """
+
+    def __init__(self, x, y=0):
+        Matrix.__init__(self)
+        self._x, self._y = x, y
+        self._matrix[...] = ([[1, 0, x],
+                              [0, 1, y],
+                              [0, 0, 1]])
+
+    def __repr__(self):
+        return "Translate(%g,%g)" % (self._x, self._y)
+
+
+# ------------------------------------------------------------------- Scale ---
+class Scale(Matrix):
+    """
+    Scaling is equivalent to the matrix [sx 0 0 sy 0 0]. One unit in the X and
+    Y directions in the new coordinate system equals sx and sy units in the
+    previous coordinate system, respectively.
+    """
+
+    def __init__(self, x, y=0):
+        Matrix.__init__(self)
+        self._x = x
+        self._y = y or x
+        self._matrix[...] = ([[x, 0, 0],
+                              [0, y, 0],
+                              [0, 0, 1]])
+
+    def __repr__(self):
+        return "Scale(%g,%g)" % (self._x, self._y)
+
+
+# ------------------------------------------------------------------- Scale ---
+class Rotate(Matrix):
+    """
+    Rotation about the origin is equivalent to the matrix [cos(a) sin(a)
+    -sin(a) cos(a) 0 0], which has the effect of rotating the coordinate system
+    axes by angle a.
+    """
+
+    def __init__(self, angle, x=0, y=0):
+        Matrix.__init__(self)
+        self._angle = angle
+        self._x = x
+        self._y = y
+
+        angle = math.pi * angle / 180.0
+        rotate = np.array([[math.cos(angle), -math.sin(angle), 0],
+                           [math.sin(angle), math.cos(angle), 0],
+                           [0, 0, 1]], dtype=float)
+        forward = np.array([[1, 0, x],
+                            [0, 1, y],
+                            [0, 0, 1]], dtype=float)
+        inverse = np.array([[1, 0, -x],
+                            [0, 1, -y],
+                            [0, 0, 1]], dtype=float)
+        self._matrix = np.dot(inverse, np.dot(rotate, forward))
+
+    def __repr__(self):
+        return "Rotate(%g,%g,%g)" % (self._angle, self._x, self._y)
+
+
+# ------------------------------------------------------------------- SkewX ---
+class SkewX(Matrix):
+    """
+    A skew transformation along the x-axis is equivalent to the matrix [1 0
+    tan(a) 1 0 0], which has the effect of skewing X coordinates by angle a.
+    """
+
+    def __init__(self, angle):
+        Matrix.__init__(self)
+        self._angle = angle
+        angle = math.pi * angle / 180.0
+        self._matrix[...] = ([[1, math.tan(angle), 0],
+                              [0, 1, 0],
+                              [0, 0, 1]])
+
+    def __repr__(self):
+        return "SkewX(%g)" % (self._angle)
+
+
+# ------------------------------------------------------------------- SkewY ---
+class SkewY(Matrix):
+    """
+    A skew transformation along the y-axis is equivalent to the matrix [1
+    tan(a) 0 1 0 0], which has the effect of skewing Y coordinates by angle a.
+    """
+
+    def __init__(self, angle):
+        Matrix.__init__(self)
+        self._angle = angle
+        angle = math.pi * angle / 180.0
+        self._matrix[...] = ([[1, 0, 0],
+                              [math.tan(angle), 1, 0],
+                              [0, 0, 1]])
+
+    def __repr__(self):
+        return "SkewY(%g)" % (self._angle)
+
+
+# --------------------------------------------------------------- Transform ---
+class Transform(object):
+    """
+    A Transform is defined as a list of transform definitions, which are
+    applied in the order provided. The individual transform definitions are
+    separated by whitespace and/or a comma.
+    """
+
+    def __init__(self, content=""):
+        self._transforms = []
+        if not content:
+            return
+
+        converters = {"matrix": Matrix,
+                      "scale": Scale,
+                      "rotate": Rotate,
+                      "translate": Translate,
+                      "skewx": SkewX,
+                      "skewy": SkewY}
+        keys = "|".join(converters.keys())
+        pattern = r"(?P<name>%s)\s*\((?P<args>[^)]*)\)" % keys
+
+        for match in re.finditer(pattern, content):
+            name = match.group("name").strip()
+            args = match.group("args").strip().replace(',', ' ')
+            args = [float(value) for value in args.split()]
+            transform = converters[name](*args)
+            self._transforms.append(transform)
+
+    def __add__(self, other):
+        T = Transform()
+        T._transforms.extend(self._transforms)
+        T._transforms.extend(other._transforms)
+        return T
+
+    def __radd__(self, other):
+        self._transforms.extend(other._transforms)
+        return self
+
+    @property
+    def matrix(self):
+        M = np.eye(3)
+        for transform in self._transforms:
+            M = np.dot(M, transform)
+        return M
+
+    def __array__(self, *args):
+        return self._matrix
+
+    def __repr__(self):
+        s = ""
+        for i in range(len(self._transforms)):
+            s += repr(self._transforms[i])
+            if i < len(self._transforms) - 1:
+                s += ", "
+        return s
+
+    @property
+    def xml(self):
+        return self._xml()
+
+    def _xml(self, prefix=""):
+
+        identity = True
+        for transform in self._transforms:
+            if not isinstance(transform, Identity):
+                identity = False
+                break
+        if identity:
+            return ""
+
+        return 'transform="%s" ' % repr(self)