vispy 0.15.0__cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl

vispy/visuals/border.py

@@ -0,0 +1,208 @@
+# -*- coding: utf-8 -*-
+# -----------------------------------------------------------------------------
+# Copyright (c) Vispy Development Team. All Rights Reserved.
+# Distributed under the (new) BSD License. See LICENSE.txt for more info.
+# -----------------------------------------------------------------------------
+# Author: Siddharth Bhat
+# -----------------------------------------------------------------------------
+
+import numpy as np
+
+from . import Visual
+from ..color import Color
+
+_VERTEX_SHADER = """
+attribute vec2 a_position;
+attribute vec2 a_adjust_dir;
+
+void main() {
+    // First map the vertex to document coordinates
+    vec4 doc_pos = $visual_to_doc(vec4(a_position, 0, 1));
+
+    // Also need to map the adjustment direction vector, but this is tricky!
+    // We need to adjust separately for each component of the vector:
+    vec4 adjusted;
+    if ( a_adjust_dir.x == 0. ) {
+        // If this is an outer vertex, no adjustment for line weight is needed.
+        // (In fact, trying to make the adjustment would result in no
+        // triangles being drawn, hence the if/else block)
+        adjusted = doc_pos;
+    }
+    else {
+        // Inner vertexes must be adjusted for line width, but this is
+        // surprisingly tricky given that the rectangle may have been scaled
+        // and rotated!
+        vec4 doc_x = $visual_to_doc(vec4(a_adjust_dir.x, 0., 0., 0.)) -
+                    $visual_to_doc(vec4(0., 0., 0., 0.));
+        vec4 doc_y = $visual_to_doc(vec4(0, a_adjust_dir.y, 0., 0.)) -
+                    $visual_to_doc(vec4(0., 0., 0., 0.));
+        doc_x = normalize(doc_x);
+        doc_y = normalize(doc_y);
+
+        // Now doc_x + doc_y points in the direction we need in order to
+        // correct the line weight of _both_ segments, but the magnitude of
+        // that correction is wrong. To correct it we first need to
+        // measure the width that would result from using doc_x + doc_y:
+        vec4 proj_y_x = dot(doc_x, doc_y) * doc_x;  // project y onto x
+        float cur_width = length(doc_y - proj_y_x);  // measure current weight
+
+        // And now we can adjust vertex position for line width:
+        adjusted = doc_pos + ($border_width / cur_width) * (doc_x + doc_y);
+    }
+
+    // Finally map the remainder of the way to render coordinates
+    gl_Position = $doc_to_render(adjusted);
+}
+"""
+
+_FRAGMENT_SHADER = """
+void main() {
+    gl_FragColor = $border_color;
+}
+"""  # noqa
+
+
+class _BorderVisual(Visual):
+    """
+    Visual subclass to display 2D pixel-width borders.
+
+    Parameters
+    ----------
+    pos : tuple (x, y)
+        Position where the colorbar is to be placed with
+        respect to the center of the colorbar
+    halfdim : tuple (half_width, half_height)
+        Half the dimensions of the colorbar measured
+        from the center. That way, the total dimensions
+        of the colorbar is (x - half_width) to (x + half_width)
+        and (y - half_height) to (y + half_height)
+    border_width : float (in px)
+        The width of the border the colormap should have. This measurement
+        is given in pixels
+    border_color : str | vispy.color.Color
+        The color of the border of the colormap. This can either be a
+        str as the color's name or an actual instace of a vipy.color.Color
+    """
+
+    _shaders = {
+        'vertex': _VERTEX_SHADER,
+        'fragment': _FRAGMENT_SHADER,
+    }
+
+    def __init__(self, pos, halfdim,
+                 border_width=1.0,
+                 border_color=None,
+                 **kwargs):
+
+        self._pos = pos
+        self._halfdim = halfdim
+        self._border_width = border_width
+        self._border_color = Color(border_color)
+
+        Visual.__init__(self, vcode=self._shaders['vertex'], fcode=self._shaders['fragment'])
+
+    @staticmethod
+    def _prepare_transforms(view):
+
+        program = view.shared_program
+        program.vert['visual_to_doc'] = \
+            view.transforms.get_transform('visual', 'document')
+        program.vert['doc_to_render'] = \
+            view.transforms.get_transform('document', 'render')
+
+    @property
+    def visual_border_width(self):
+        """The border width in visual coordinates"""
+        render_to_doc =  \
+            self.transforms.get_transform('document', 'visual')
+
+        vec = render_to_doc.map([self.border_width, self.border_width, 0])
+        origin = render_to_doc.map([0, 0, 0])
+
+        visual_border_width = [vec[0] - origin[0], vec[1] - origin[1]]
+
+        # we need to flip the y axis because coordinate systems are inverted
+        visual_border_width[1] *= -1
+
+        return visual_border_width
+
+    def _update(self):
+        x, y = self._pos
+        halfw, halfh = self._halfdim
+
+        border_vertices = np.array([
+            [x - halfw, y - halfh],
+            [x - halfw, y - halfh],
+
+            [x + halfw, y - halfh],
+            [x + halfw, y - halfh],
+
+            [x + halfw, y + halfh],
+            [x + halfw, y + halfh],
+
+            [x - halfw, y + halfh],
+            [x - halfw, y + halfh],
+
+            [x - halfw, y - halfh],
+            [x - halfw, y - halfh],
+        ], dtype=np.float32)
+
+        # Direction each vertex should move to correct for line width
+        adjust_dir = np.array([
+            [0, 0], [-1, -1],
+            [0, 0], [1, -1],
+            [0, 0], [1, 1],
+            [0, 0], [-1, 1],
+            [0, 0], [-1, -1],
+        ], dtype=np.float32)
+
+        self.shared_program['a_position'] = border_vertices
+        self.shared_program['a_adjust_dir'] = adjust_dir
+        self.shared_program.vert['border_width'] = float(self._border_width)
+        self.shared_program.frag['border_color'] = self._border_color.rgba
+
+    def _prepare_draw(self, view=None):
+        self._update()
+        self._draw_mode = "triangle_strip"
+        return True
+
+    @property
+    def border_width(self):
+        """The width of the border"""
+        return self._border_width
+
+    @border_width.setter
+    def border_width(self, border_width):
+        self._border_width = border_width
+        # positions of text need to be changed accordingly
+        self._update()
+
+    @property
+    def border_color(self):
+        """The color of the border in pixels"""
+        return self._border_color
+
+    @border_color.setter
+    def border_color(self, border_color):
+        self._border_color = Color(border_color)
+        self.shared_program.frag['border_color'] = self._border_color.rgba
+
+    @property
+    def pos(self):
+        """The center of the BorderVisual"""
+        return self._pos
+
+    @pos.setter
+    def pos(self, pos):
+        self._pos = pos
+        self._update()
+
+    @property
+    def halfdim(self):
+        """The half-dimensions measured from the center of the BorderVisual"""
+        return self._halfdim
+
+    @halfdim.setter
+    def halfdim(self, halfdim):
+        self._halfdim = halfdim
+        self._update()

vispy/visuals/box.py

@@ -0,0 +1,79 @@
+# -*- coding: utf-8 -*-
+# -----------------------------------------------------------------------------
+# Copyright (c) Vispy Development Team. All Rights Reserved.
+# Distributed under the (new) BSD License. See LICENSE.txt for more info.
+# -----------------------------------------------------------------------------
+
+from ..geometry import create_box
+from .mesh import MeshVisual
+from .visual import CompoundVisual
+
+
+class BoxVisual(CompoundVisual):
+    """Visual that displays a box.
+
+    Parameters
+    ----------
+    width : float
+        Box width.
+    height : float
+        Box height.
+    depth : float
+        Box depth.
+    width_segments : int
+        Box segments count along the width.
+    height_segments : float
+        Box segments count along the height.
+    depth_segments : float
+        Box segments count along the depth.
+    planes: array_like
+        Any combination of ``{'-x', '+x', '-y', '+y', '-z', '+z'}``
+        Included planes in the box construction.
+    vertex_colors : ndarray
+        Same as for `MeshVisual` class. See `create_plane` for vertex ordering.
+    face_colors : ndarray
+        Same as for `MeshVisual` class. See `create_plane` for vertex ordering.
+    color : Color
+        The `Color` to use when drawing the cube faces.
+    edge_color : tuple or Color
+        The `Color` to use when drawing the cube edges. If `None`, then no
+        cube edges are drawn.
+    """
+
+    def __init__(self, width=1, height=1, depth=1, width_segments=1,
+                 height_segments=1, depth_segments=1, planes=None,
+                 vertex_colors=None, face_colors=None,
+                 color=(0.5, 0.5, 1, 1), edge_color=None, **kwargs):
+        vertices, filled_indices, outline_indices = create_box(
+            width, height, depth, width_segments, height_segments,
+            depth_segments, planes)
+
+        self._mesh = MeshVisual(vertices['position'], filled_indices,
+                                vertex_colors, face_colors, color)
+        if edge_color:
+            self._border = MeshVisual(vertices['position'], outline_indices,
+                                      color=edge_color, mode='lines')
+        else:
+            self._border = MeshVisual()
+
+        CompoundVisual.__init__(self, [self._mesh, self._border], **kwargs)
+        self.mesh.set_gl_state(polygon_offset_fill=True,
+                               polygon_offset=(1, 1), depth_test=True)
+
+    @property
+    def mesh(self):
+        """The vispy.visuals.MeshVisual that used to fill in."""
+        return self._mesh
+
+    @mesh.setter
+    def mesh(self, mesh):
+        self._mesh = mesh
+
+    @property
+    def border(self):
+        """The vispy.visuals.MeshVisual that used to draw the border."""
+        return self._border
+
+    @border.setter
+    def border(self, border):
+        self._border = border

vispy/visuals/collections/__init__.py

@@ -0,0 +1,30 @@
+# -*- coding: utf-8 -*-
+# -----------------------------------------------------------------------------
+# Copyright (c) Vispy Development Team. All Rights Reserved.
+# Distributed under the (new) BSD License. See LICENSE.txt for more info.
+# -----------------------------------------------------------------------------
+"""
+Collections allow batch rendering of object of the same type:
+
+ - Points
+ - Line segments
+ - Polylines (paths)
+ - Raw Triangles
+ - Polygons
+
+Each collection has several modes:
+
+ - raw (point, segment, path, triangle, polygon)
+ - agg (point, segment, path, polygon)
+ - agg+ (path, polygon)
+
+Note: Storage of shared attributes requires non-clamped textures which is not
+      the case on all graphic cards. This means such shared attributes must be
+      normalized on CPU and scales back on GPU (in shader code).
+"""
+
+from . path_collection import PathCollection  # noqa
+from . point_collection import PointCollection  # noqa
+from . polygon_collection import PolygonCollection  # noqa
+from . segment_collection import SegmentCollection  # noqa
+from . triangle_collection import TriangleCollection  # noqa

vispy/visuals/collections/agg_fast_path_collection.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.
+# -----------------------------------------------------------------------------
+"""
+Antigrain Geometry Fast Path Collection
+
+This collection provides antialiased and accurate paths with caps and miter
+joins. It consume x4 more memory than regular lines and is a bit slower, but
+the quality of the output is worth the cost. Note that no control can be made
+on miter joins which may result in some glitches on screen.
+"""
+import numpy as np
+from ... import glsl
+from ... import gloo
+from . collection import Collection
+from ..transforms import NullTransform
+
+
+class AggFastPathCollection(Collection):
+    """
+    Antigrain Geometry Fast Path Collection
+
+    This collection provides antialiased and accurate paths with caps and miter
+    joins. It consume x4 more memory than regular lines and is a bit slower,
+    but the quality of the output is worth the cost. Note that no control can
+    be made on miter joins which may result in some glitches on screen.
+    """
+
+    def __init__(self, user_dtype=None, transform=None,
+                 vertex=None, fragment=None, **kwargs):
+        """
+        Initialize the collection.
+
+        Parameters
+        ----------
+        user_dtype: list
+            The base dtype can be completed (appended) by the used_dtype. It
+            only make sense if user also provide vertex and/or fragment shaders
+
+        transform : string
+            GLSL Transform code defining the vec4 transform(vec3) function
+
+        vertex: string
+            Vertex shader code
+
+        fragment: string
+            Fragment  shader code
+
+        caps : string
+            'local', 'shared' or 'global'
+
+        color : string
+            'local', 'shared' or 'global'
+
+        linewidth : string
+            'local', 'shared' or 'global'
+
+        antialias : string
+            'local', 'shared' or 'global'
+        """
+        base_dtype = [('prev', (np.float32, 3), '!local', (0, 0, 0)),
+                      ('curr', (np.float32, 3), '!local', (0, 0, 0)),
+                      ('next', (np.float32, 3), '!local', (0, 0, 0)),
+                      ('id', (np.float32, 1), '!local', 0),
+                      ('color', (np.float32, 4), 'global', (0, 0, 0, 1)),
+                      ('linewidth', (np.float32, 1), 'global', 1),
+                      ('antialias', (np.float32, 1), 'global', 1),
+                      ("viewport", (np.float32, 4), 'global', (0, 0, 512, 512))]  # noqa
+        dtype = base_dtype
+        if user_dtype:
+            dtype.extend(user_dtype)
+
+        if vertex is None:
+            vertex = glsl.get('collections/agg-fast-path.vert')
+        if transform is None:
+            transform = NullTransform()
+        self.transform = transform
+        if fragment is None:
+            fragment = glsl.get('collections/agg-fast-path.frag')
+
+        Collection.__init__(self, dtype=dtype, itype=None,
+                            mode="triangle_strip",
+                            vertex=vertex, fragment=fragment, **kwargs)
+
+        program = self._programs[0]
+        program.vert['transform'] = self.transform
+
+    def append(self, P, closed=False, itemsize=None, **kwargs):
+        """
+        Append a new set of vertices to the collection.
+
+        For kwargs argument, n is the number of vertices (local) or the number
+        of item (shared)
+
+        Parameters
+        ----------
+        P : np.array
+            Vertices positions of the path(s) to be added
+
+        closed: bool
+            Whether path(s) is/are closed
+
+        itemsize: int or None
+            Size of an individual path
+
+        caps : list, array or 2-tuple
+           Path start /end cap
+
+        color : list, array or 4-tuple
+           Path color
+
+        linewidth : list, array or float
+           Path linewidth
+
+        antialias : list, array or float
+           Path antialias area
+        """
+        itemsize = int(itemsize or len(P))
+        itemcount = len(P) // itemsize
+
+        P = P.reshape(itemcount, itemsize, 3)
+        if closed:
+            V = np.empty((itemcount, itemsize + 3), dtype=self.vtype)
+            # Apply default values on vertices
+            for name in self.vtype.names:
+                if name not in ['collection_index', 'prev', 'curr', 'next']:
+                    V[name][1:-2] = kwargs.get(name, self._defaults[name])
+            V['prev'][:, 2:-1] = P
+            V['prev'][:, 1] = V['prev'][:, -2]
+            V['curr'][:, 1:-2] = P
+            V['curr'][:, -2] = V['curr'][:, 1]
+            V['next'][:, 0:-3] = P
+            V['next'][:, -3] = V['next'][:, 0]
+            V['next'][:, -2] = V['next'][:, 1]
+        else:
+            V = np.empty((itemcount, itemsize + 2), dtype=self.vtype)
+            # Apply default values on vertices
+            for name in self.vtype.names:
+                if name not in ['collection_index', 'prev', 'curr', 'next']:
+                    V[name][1:-1] = kwargs.get(name, self._defaults[name])
+            V['prev'][:, 2:] = P
+            V['prev'][:, 1] = V['prev'][:, 2]
+            V['curr'][:, 1:-1] = P
+            V['next'][:, :-2] = P
+            V['next'][:, -2] = V['next'][:, -3]
+
+        V[:, 0] = V[:, 1]
+        V[:, -1] = V[:, -2]
+        V = V.ravel()
+        V = np.repeat(V, 2, axis=0)
+        V['id'] = np.tile([1, -1], len(V) // 2)
+        if closed:
+            V = V.reshape(itemcount, 2 * (itemsize + 3))
+        else:
+            V = V.reshape(itemcount, 2 * (itemsize + 2))
+        V["id"][:, :2] = 2, -2
+        V["id"][:, -2:] = 2, -2
+        V = V.ravel()
+
+        # Uniforms
+        if self.utype:
+            U = np.zeros(itemcount, dtype=self.utype)
+            for name in self.utype.names:
+                if name not in ["__unused__"]:
+                    U[name] = kwargs.get(name, self._defaults[name])
+        else:
+            U = None
+
+        Collection.append(self, vertices=V, uniforms=U,
+                          itemsize=2 * (itemsize + 2 + closed))
+
+    def bake(self, P, key='curr', closed=False, itemsize=None):
+        """
+        Given a path P, return the baked vertices as they should be copied in
+        the collection if the path has already been appended.
+
+        Examples
+        --------
+        >>> paths.append(P)
+        >>> P *= 2
+        >>> paths['prev'][0] = bake(P,'prev')
+        >>> paths['curr'][0] = bake(P,'curr')
+        >>> paths['next'][0] = bake(P,'next')
+
+        """
+        itemsize = itemsize or len(P)
+        itemcount = len(P) / itemsize  # noqa
+        n = itemsize
+
+        if closed:
+            idxs = np.arange(n + 3)
+            if key == 'prev':
+                idxs -= 2
+                idxs[0], idxs[1], idxs[-1] = n - 1, n - 1, n - 1
+            elif key == 'next':
+                idxs[0], idxs[-3], idxs[-2], idxs[-1] = 1, 0, 1, 1
+            else:
+                idxs -= 1
+                idxs[0], idxs[-1], idxs[n + 1] = 0, 0, 0
+        else:
+            idxs = np.arange(n + 2)
+            if key == 'prev':
+                idxs -= 2
+                idxs[0], idxs[1], idxs[-1] = 0, 0, n - 2
+            elif key == 'next':
+                idxs[0], idxs[-1], idxs[-2] = 1, n - 1, n - 1
+            else:
+                idxs -= 1
+                idxs[0], idxs[-1] = 0, n - 1
+        idxs = np.repeat(idxs, 2)
+        return P[idxs]
+
+    def draw(self, mode="triangle_strip"):
+        """Draw collection"""
+        gloo.set_depth_mask(0)
+        Collection.draw(self, mode)
+        gloo.set_depth_mask(1)