vispy 0.15.0__cp313-cp313-macosx_11_0_arm64.whl

vispy/visuals/polygon.py

@@ -0,0 +1,145 @@
+# -*- coding: utf-8 -*-
+# Copyright (c) Vispy Development Team. All Rights Reserved.
+# Distributed under the (new) BSD License. See LICENSE.txt for more info.
+
+
+"""Simple polygon visual based on MeshVisual and LineVisual"""
+
+from __future__ import division
+
+import numpy as np
+
+from .visual import CompoundVisual
+from .mesh import MeshVisual
+from .line import LineVisual
+from ..color import Color
+from ..geometry import PolygonData
+from ..gloo import set_state
+
+
+class PolygonVisual(CompoundVisual):
+    """
+    Displays a 2D polygon
+
+    Parameters
+    ----------
+    pos : array
+        Set of vertices defining the polygon.
+    color : str | tuple | list of colors
+        Fill color of the polygon.
+    border_color : str | tuple | list of colors
+        Border color of the polygon.
+    border_width : int
+        Border width in pixels.
+        Line widths > 1px are only
+        guaranteed to work when using `border_method='agg'` method.
+    border_method : str
+        Mode to use for drawing the border line (see `LineVisual`).
+
+            * "agg" uses anti-grain geometry to draw nicely antialiased lines
+              with proper joins and endcaps.
+            * "gl" uses OpenGL's built-in line rendering. This is much faster,
+              but produces much lower-quality results and is not guaranteed to
+              obey the requested line width or join/endcap styles.
+
+    triangulate : boolean
+        Triangulate the set of vertices
+    **kwargs : dict
+        Keyword arguments to pass to `CompoundVisual`.
+    """
+
+    def __init__(self, pos=None, color='black',
+                 border_color=None, border_width=1, border_method='gl',
+                 triangulate=True, **kwargs):
+        self._mesh = MeshVisual()
+        self._border = LineVisual(method=border_method)
+        self._pos = pos
+        self._color = Color(color)
+        self._border_width = border_width
+        self._border_color = Color(border_color)
+        self._triangulate = triangulate
+
+        self._update()
+        CompoundVisual.__init__(self, [self._mesh, self._border], **kwargs)
+        self._mesh.set_gl_state(polygon_offset_fill=True,
+                                polygon_offset=(1, 1), cull_face=False)
+        self.freeze()
+
+    def _update(self):
+        if self._pos is None:
+            return
+        if not self._color.is_blank and self._triangulate:
+            data = PolygonData(vertices=np.array(self._pos, dtype=np.float32))
+            pts, tris = data.triangulate()
+            set_state(polygon_offset_fill=False)
+            self._mesh.set_data(vertices=pts, faces=tris.astype(np.uint32),
+                                color=self._color.rgba)
+        elif not self._color.is_blank:
+            self.mesh.set_data(vertices=self._pos,
+                               color=self._color.rgba)
+
+        if not self._border_color.is_blank:
+            # Close border if it is not already.
+            border_pos = self._pos
+            if np.any(border_pos[0] != border_pos[-1]):
+                border_pos = np.concatenate([border_pos, border_pos[:1]],
+                                            axis=0)
+            self._border.set_data(pos=border_pos,
+                                  color=self._border_color.rgba,
+                                  width=self._border_width)
+
+            self._border.update()
+
+    @property
+    def pos(self):
+        """The vertex position of the polygon."""
+        return self._pos
+
+    @pos.setter
+    def pos(self, pos):
+        self._pos = pos
+        self._update()
+
+    @property
+    def color(self):
+        """The color of the polygon."""
+        return self._color
+
+    @color.setter
+    def color(self, color):
+        self._color = Color(color, clip=True)
+        self._update()
+
+    @property
+    def border_color(self):
+        """The border color of the polygon."""
+        return self._border_color
+
+    @border_color.setter
+    def border_color(self, border_color):
+        self._border_color = Color(border_color)
+        self._update()
+
+    @property
+    def mesh(self):
+        """The vispy.visuals.MeshVisual that is owned by the PolygonVisual.
+        It is used to fill in the polygon
+        """
+        return self._mesh
+
+    @mesh.setter
+    def mesh(self, mesh):
+        self._mesh = mesh
+        self._update()
+
+    @property
+    def border(self):
+        """The vispy.visuals.LineVisual that is owned by the PolygonVisual.
+        It is used to draw the border of the polygon
+        """
+        return self._border
+
+    @border.setter
+    def border(self, border):
+        self._border = border
+        self._update()

vispy/visuals/rectangle.py

@@ -0,0 +1,196 @@
+# -*- coding: utf-8 -*-
+# Copradiusight (c) 2014, Vispy Development Team.
+# Distributed under the (new) BSD License. See LICENSE.txt for more info.
+
+
+"""Simple ellipse visual based on PolygonVisual"""
+
+from __future__ import division
+
+import numpy as np
+from ..color import Color
+from .polygon import PolygonVisual
+
+
+class RectangleVisual(PolygonVisual):
+    """
+    Displays a 2D rectangle with optional rounded corners
+
+    Parameters
+    ----------
+    center :  array
+        Center of the rectangle
+    color : instance of Color
+        The fill color to use.
+    border_color : instance of Color
+        The border color to use.
+    border_width : int
+        Border width in pixels.
+        Line widths > 1px are only
+        guaranteed to work when using `border_method='agg'` method.
+    height : float
+        Length of the rectangle along y-axis
+        Defaults to 1.0
+    width : float
+        Length of the rectangle along x-axis
+        Defaults to 1.0
+    radius : float | array
+        Radii of curvatures of corners in clockwise order from top-left
+        Defaults to 0.
+    **kwargs : dict
+        Keyword arguments to pass to `PolygonVisual`.
+    """
+
+    def __init__(self, center=None, color='black', border_color=None,
+                 border_width=1, height=1.0, width=1.0,
+                 radius=[0., 0., 0., 0.], **kwargs):
+
+        self._height = height
+        self._width = width
+        self._color = Color(color)
+        self._border_color = Color(border_color)
+        self._border_width = border_width
+        self._radius = radius
+        self._center = center
+
+        # triangulation can be very slow
+        kwargs.setdefault('triangulate', False)
+        PolygonVisual.__init__(self, pos=None, color=color,
+                               border_color=border_color,
+                               border_width=border_width, **kwargs)
+
+        self._mesh.mode = 'triangle_fan'
+        self._regen_pos()
+        self._update()
+
+    @staticmethod
+    def _generate_vertices(center, radius, height, width):
+        half_height = height / 2.
+        half_width = width / 2.
+        hw = min(half_height, half_width)
+
+        if isinstance(radius, (list, tuple)):
+            if len(radius) != 4:
+                raise ValueError("radius must be float or 4 value tuple/list"
+                                 " (got %s of length %d)" % (type(radius),
+                                                             len(radius)))
+
+            if (radius > np.ones(4) * hw).all():
+                raise ValueError('Radius of curvature cannot be greater than\
+                                  half of min(width, height)')
+            radius = np.array(radius, dtype=np.float32)
+
+        else:
+            if radius > hw:
+                raise ValueError('Radius of curvature cannot be greater than\
+                                  half of min(width, height)')
+            radius = np.ones(4) * radius
+
+        num_segments = (radius / hw * 500.).astype(int)
+
+        bias1 = np.ones(4) * half_width - radius
+        bias2 = np.ones(4) * half_height - radius
+
+        corner1 = np.empty([num_segments[0]+1, 3], dtype=np.float32)
+        corner2 = np.empty([num_segments[1]+1, 3], dtype=np.float32)
+        corner3 = np.empty([num_segments[2]+1, 3], dtype=np.float32)
+        corner4 = np.empty([num_segments[3]+1, 3], dtype=np.float32)
+
+        start_angle = 0.
+        end_angle = np.pi / 2.
+
+        theta = np.linspace(end_angle, start_angle, num_segments[0]+1)
+
+        corner1[:, 0] = center[0] - bias1[0] - radius[0] * np.sin(theta)
+        corner1[:, 1] = center[1] - bias2[0] - radius[0] * np.cos(theta)
+        corner1[:, 2] = 0
+
+        theta = np.linspace(start_angle, end_angle, num_segments[1]+1)
+
+        corner2[:, 0] = center[0] + bias1[1] + radius[1] * np.sin(theta)
+        corner2[:, 1] = center[1] - bias2[1] - radius[1] * np.cos(theta)
+        corner2[:, 2] = 0
+
+        theta = np.linspace(end_angle, start_angle, num_segments[2]+1)
+
+        corner3[:, 0] = center[0] + bias1[2] + radius[2] * np.sin(theta)
+        corner3[:, 1] = center[1] + bias2[2] + radius[2] * np.cos(theta)
+        corner3[:, 2] = 0
+
+        theta = np.linspace(start_angle, end_angle, num_segments[3]+1)
+
+        corner4[:, 0] = center[0] - bias1[3] - radius[3] * np.sin(theta)
+        corner4[:, 1] = center[1] + bias2[3] + radius[3] * np.cos(theta)
+        corner4[:, 2] = 0
+
+        output = np.concatenate(([[center[0], center[1], 0.]],
+                                 [[center[0] - half_width, center[1], 0.]],
+                                 corner1,
+                                 [[center[0], center[1] - half_height, 0.]],
+                                 corner2,
+                                 [[center[0] + half_width, center[1], 0.]],
+                                 corner3,
+                                 [[center[0], center[1] + half_height, 0.]],
+                                 corner4,
+                                 [[center[0] - half_width, center[1], 0.]]))
+
+        vertices = np.array(output, dtype=np.float32)
+        return vertices
+
+    @property
+    def center(self):
+        """The center of the ellipse"""
+        return self._center
+
+    @center.setter
+    def center(self, center):
+        """The center of the ellipse"""
+        self._center = center
+        self._regen_pos()
+        self._update()
+
+    @property
+    def height(self):
+        """The height of the rectangle."""
+        return self._height
+
+    @height.setter
+    def height(self, height):
+        if height <= 0.:
+            raise ValueError('Height must be positive')
+        self._height = height
+        self._regen_pos()
+        self._update()
+
+    @property
+    def width(self):
+        """The width of the rectangle."""
+        return self._width
+
+    @width.setter
+    def width(self, width):
+        if width <= 0.:
+            raise ValueError('Width must be positive')
+        self._width = width
+        self._regen_pos()
+        self._update()
+
+    @property
+    def radius(self):
+        """The radius of curvature of rounded corners."""
+        return self._radius
+
+    @radius.setter
+    def radius(self, radius):
+        self._radius = radius
+        self._regen_pos()
+        self._update()
+
+    def _regen_pos(self):
+        vertices = self._generate_vertices(center=self._center,
+                                           radius=self._radius,
+                                           height=self._height,
+                                           width=self._width)
+        # don't use the center point and only use X/Y coordinates
+        vertices = vertices[1:, ..., :2]
+        self._pos = vertices

vispy/visuals/regular_polygon.py

@@ -0,0 +1,56 @@
+# -*- coding: utf-8 -*-
+# Copyright (c) Vispy Development Team. All Rights Reserved.
+# Distributed under the (new) BSD License. See LICENSE.txt for more info.
+
+
+"""RegularPolygonVisual visual based on EllipseVisual"""
+
+from __future__ import division
+
+from .ellipse import EllipseVisual
+
+
+class RegularPolygonVisual(EllipseVisual):
+    """
+    Displays a regular polygon
+
+    Parameters
+    ----------
+    center : array-like (x, y)
+        Center of the regular polygon
+    color : str | tuple | list of colors
+        Fill color of the polygon
+    border_color : str | tuple | list of colors
+        Border color of the polygon
+    border_width: float
+        The width of the border in pixels
+    radius : float
+        Radius of the regular polygon
+        Defaults to  0.1
+    sides : int
+        Number of sides of the regular polygon
+    """
+
+    def __init__(self, center=None, color='black', border_color=None,
+                 border_width=1, radius=0.1, sides=4, **kwargs):
+        EllipseVisual.__init__(self, center=center,
+                               radius=radius,
+                               color=color,
+                               border_color=border_color,
+                               border_width=border_width,
+                               num_segments=sides, **kwargs)
+
+    @property
+    def sides(self):
+        """The number of sides in the regular polygon."""
+        # return using the property accessor for num_segments
+        return self.num_segments
+
+    @sides.setter
+    def sides(self, sides):
+        if sides < 3:
+            raise ValueError('PolygonVisual must have at least 3 sides, not %s'
+                             % sides)
+        # edit using the property accessor of num_segments so this
+        # internally calls the update()
+        self.num_segments = sides

vispy/visuals/scrolling_lines.py

@@ -0,0 +1,197 @@
+# -*- 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
+
+from .visual import Visual
+from .. import gloo
+
+
+class ScrollingLinesVisual(Visual):
+    """Displays many line strips of equal length, with the option to add new
+    vertex data to one end of the lines.
+
+    Parameters
+    ----------
+    n_lines : int
+        The number of independent line strips to draw.
+    line_size : int
+        The number of samples in each line strip.
+    dx : float
+        The x distance between samples
+    color : array-like
+        An array of colors to assign to each line strip.
+    pos_offset : array-like
+        An array of x, y position offsets to apply to each line strip.
+    columns : int
+        Arrange line strips into a grid with this number of columns. This
+        option is not compatible with *pos_offset*.
+    cell_size : tuple
+        The x, y distance between cells in the grid.
+    """
+
+    vertex_code = """
+    attribute vec2 index;  // .x=line_n, .y=vertex_n
+    uniform sampler2D position;
+    uniform sampler1D pos_offset;
+    uniform sampler1D color_tex;
+    
+    uniform vec2 pos_size;  // x=n_lines, y=n_verts_per_line
+    uniform float offset;  // rolling pointer into vertexes
+    uniform float dx;  // x step per sample
+    
+    varying vec2 v_index;
+    varying vec4 v_color;
+    
+    
+    void main() {
+        v_index = vec2(mod(index.y + offset, pos_size.y), index.x);
+        vec2 uv = (v_index + 0.5) / (pos_size.yx);
+        vec4 pos = vec4(index.y * dx, texture2D(position, uv).r, 0, 1);
+        
+        // fetch starting position from texture lookup:
+        pos += vec4(texture1D(pos_offset, (index.x + 0.5) / pos_size.x).rg,
+                              0, 0); 
+        
+        gl_Position = $transform(pos);
+        
+        v_color = texture1D(color_tex, (index.x + 0.5) / pos_size.x);
+    }
+    """
+
+    fragment_code = """
+    varying vec2 v_index;
+    varying vec4 v_color;
+    
+    void main() {
+        if (v_index.y - floor(v_index.y) > 0) {
+            discard;
+        }
+        gl_FragColor = $color;
+    }
+    """
+
+    def __init__(self, n_lines, line_size, dx, color=None, pos_offset=None,
+                 columns=None, cell_size=None):
+        self._pos_data = None
+        self._offset = 0
+        self._dx = dx
+
+        data = np.zeros((n_lines, line_size), dtype='float32')
+        self._pos_tex = gloo.Texture2D(data, format='luminance',
+                                       internalformat='r32f')
+        self._index_buf = gloo.VertexBuffer()
+        self._data_shape = data.shape
+
+        Visual.__init__(self, vcode=self.vertex_code, fcode=self.fragment_code)
+
+        self.shared_program['position'] = self._pos_tex
+        self.shared_program['index'] = self._index_buf
+        self.shared_program['dx'] = dx
+        self.shared_program['pos_size'] = data.shape
+        self.shared_program['offset'] = self._offset
+
+        # set an array giving the x/y origin for each plot
+        if pos_offset is None:
+            # construct positions as a grid 
+            rows = int(np.ceil(n_lines / columns))
+            pos_offset = np.empty((rows, columns, 3), dtype='float32')
+            pos_offset[..., 0] = (np.arange(columns)[np.newaxis, :] * 
+                                  cell_size[0])
+            pos_offset[..., 1] = np.arange(rows)[:, np.newaxis] * cell_size[1]
+            # limit position texture to the number of lines in case there are
+            # more row/column cells than lines
+            pos_offset = pos_offset.reshape((rows*columns), 3)[:n_lines, :]
+        self._pos_offset = gloo.Texture1D(pos_offset, internalformat='rgb32f',
+                                          interpolation='nearest')
+        self.shared_program['pos_offset'] = self._pos_offset
+
+        if color is None:
+            # default to white (1, 1, 1, 1)
+            self._color_tex = gloo.Texture1D(
+                np.ones((n_lines, 4), dtype=np.float32))
+            self.shared_program['color_tex'] = self._color_tex
+            self.shared_program.frag['color'] = 'v_color'
+        else:
+            self._color_tex = gloo.Texture1D(color)
+            self.shared_program['color_tex'] = self._color_tex
+            self.shared_program.frag['color'] = 'v_color'
+
+        # construct a vertex buffer index containing (plot_n, vertex_n) for
+        # each vertex
+        index = np.empty((data.shape[0], data.shape[1], 2), dtype='float32')
+        index[..., 0] = np.arange(data.shape[0])[:, np.newaxis]
+        index[..., 1] = np.arange(data.shape[1])[np.newaxis, :]
+        index = index.reshape((index.shape[0]*index.shape[1], index.shape[2]))
+        self._index_buf.set_data(index)
+
+        self._draw_mode = 'line_strip'
+        self.set_gl_state('translucent', line_width=1)
+        self.freeze()
+
+    def set_pos_offset(self, po):
+        """Set the array of position offsets for each line strip.
+
+        Parameters
+        ----------
+        po : array-like
+            An array of xy offset values.
+        """
+        self._pos_offset.set_data(po)
+
+    def set_color(self, color):
+        """Set the array of colors for each line strip.
+
+        Parameters
+        ----------
+        color : array-like
+            An array of rgba values.
+        """
+        self._color_tex.set_data(color)
+
+    def _prepare_transforms(self, view):
+        view.view_program.vert['transform'] = view.get_transform().simplified
+
+    def _prepare_draw(self, view):
+        pass
+
+    def _compute_bounds(self, axis, view):
+        if self._pos_data is None:
+            return None
+        return self._pos_data[..., axis].min(), self.pos_data[..., axis].max()
+
+    def roll_data(self, data):
+        """Append new data to the right side of every line strip and remove
+        as much data from the left.
+
+        Parameters
+        ----------
+        data : array-like
+            A data array to append.
+        """
+        data = data.astype('float32')[..., np.newaxis]
+        s1 = self._data_shape[1] - self._offset
+        if data.shape[1] > s1:
+            self._pos_tex[:, self._offset:] = data[:, :s1]
+            self._pos_tex[:, :data.shape[1] - s1] = data[:, s1:]
+            self._offset = (self._offset + data.shape[1]) % self._data_shape[1]
+        else:
+            self._pos_tex[:, self._offset:self._offset+data.shape[1]] = data
+            self._offset += data.shape[1]
+        self.shared_program['offset'] = self._offset
+        self.update()
+
+    def set_data(self, index, data):
+        """Set the complete data for a single line strip.
+
+        Parameters
+        ----------
+        index : int
+            The index of the line strip to be replaced.
+        data : array-like
+            The data to assign to the selected line strip.
+        """
+        self._pos_tex[index, :] = data
+        self.update()

vispy/visuals/shaders/__init__.py

@@ -0,0 +1,17 @@
+# -*- coding: utf-8 -*-
+# Copyright (c) Vispy Development Team. All Rights Reserved.
+# Distributed under the (new) BSD License. See LICENSE.txt for more info.
+"""
+Provides functionality for composing shaders from multiple GLSL
+code snippets.
+"""
+
+__all__ = ['ModularProgram', 'Function', 'MainFunction', 'Variable', 'Varying',
+           'FunctionChain', 'Compiler', 'MultiProgram']
+
+from .program import ModularProgram  # noqa
+from .function import Function, MainFunction, FunctionChain  # noqa
+from .function import StatementList  # noqa
+from .variable import Variable, Varying  # noqa
+from .compiler import Compiler  # noqa
+from .multiprogram import MultiProgram  # noqa