vispy 0.15.0__cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl

vispy/visuals/filters/picking.py

@@ -0,0 +1,60 @@
+# -*- coding: utf-8 -*-
+# Copyright (c) Vispy Development Team. All Rights Reserved.
+# Distributed under the (new) BSD License. See LICENSE.txt for more info.
+
+import struct
+
+from .base_filter import Filter
+
+
+class PickingFilter(Filter):
+    """Filter used to color visuals by a picking ID.
+
+    Note that the ID color uses the alpha channel, so this may not be used
+    with blending enabled.
+    """
+
+    FRAG_SHADER = """
+        void picking_filter() {
+            if( $enabled == 0 )
+                return;
+            if( gl_FragColor.a == 0.0 )
+                discard;
+            gl_FragColor = $id_color;
+        }
+    """
+
+    def __init__(self, id_=None):
+        super(PickingFilter, self).__init__(fcode=self.FRAG_SHADER, fpos=10)
+
+        self.id = id_
+        self.enabled = False
+
+    @property
+    def id(self):
+        return self._id
+
+    @id.setter
+    def id(self, id):
+        if id < 1:
+            raise ValueError('Picking ID must be integer > 0.')
+        id_color = struct.unpack('<4B', struct.pack('<I', id))
+        self.fshader['id_color'] = [x/255. for x in id_color]
+        self._id = id
+        self._id_color = id_color
+
+    @property
+    def enabled(self):
+        return self._enabled
+
+    @enabled.setter
+    def enabled(self, e):
+        self._enabled = e
+        self.fshader['enabled'] = 1 if e is True else 0
+
+    @property
+    def color(self):
+        """The RGBA color that will be drawn to the framebuffer for visuals
+        that use this filter.
+        """
+        return self._id_color

vispy/visuals/filters/tests/__init__.py

@@ -0,0 +1,3 @@
+# -*- coding: utf-8 -*- 
+# Copyright (c) Vispy Development Team. All Rights Reserved.
+# Distributed under the (new) BSD License. See LICENSE.txt for more info.

vispy/visuals/filters/tests/test_primitive_picking_filters.py

@@ -0,0 +1,70 @@
+# -*- 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 vispy.geometry import create_plane
+from vispy.scene.visuals import Markers, Mesh
+from vispy.testing import requires_application, TestingCanvas
+from vispy.visuals.filters import FacePickingFilter, MarkerPickingFilter
+
+
+def test_empty_mesh_face_picking():
+    mesh = Mesh()
+    filter = FacePickingFilter()
+    mesh.attach(filter)
+    filter.enabled = True
+
+
+@requires_application()
+def test_mesh_face_picking():
+    vertices, faces, _ = create_plane(125, 125)
+    vertices = vertices["position"]
+    vertices[:, :2] += 125 / 2
+    mesh = Mesh(vertices=vertices, faces=faces)
+    filter = FacePickingFilter()
+    mesh.attach(filter)
+
+    with TestingCanvas(size=(125, 125)) as c:
+        view = c.central_widget.add_view()
+        view.add(mesh)
+        filter.enabled = True
+        mesh.update_gl_state(blend=False)
+        picking_render = c.render(bgcolor=(0, 0, 0, 0), alpha=True)
+
+    # unpack the IDs
+    ids = picking_render.view(np.uint32)
+    # the plane is made up of two triangles and nearly fills the view
+    # pick one point on each triangle
+    assert ids[125 // 2, 125 // 4] == 1
+    assert ids[125 // 2, 3 * 125 // 4] == 2
+
+
+def test_empty_markers_picking():
+    markers = Markers()
+    filter = MarkerPickingFilter()
+    markers.attach(filter)
+    filter.enabled = True
+
+
+@requires_application()
+def test_markers_picking():
+    markers = Markers(
+        pos=np.array([[-0.5, -0.5], [0.5, 0.5]]),
+        size=5,
+    )
+    filter = MarkerPickingFilter()
+    markers.attach(filter)
+
+    with TestingCanvas(size=(125, 125)) as c:
+        view = c.central_widget.add_view(camera="panzoom")
+        view.camera.rect = (-1, -1, 2, 2)
+        view.add(markers)
+
+        filter.enabled = True
+        markers.update_gl_state(blend=False)
+        picking_render = c.render(bgcolor=(0, 0, 0, 0), alpha=True)
+        ids = picking_render.view(np.uint32)
+
+        assert ids[3 * 125 // 4, 125 // 4] == 1
+        assert ids[125 // 4, 3 * 125 // 4] == 2

vispy/visuals/filters/tests/test_wireframe_filter.py

@@ -0,0 +1,16 @@
+# -*- coding: utf-8 -*- 
+# Copyright (c) Vispy Development Team. All Rights Reserved.
+# Distributed under the (new) BSD License. See LICENSE.txt for more info.
+
+from vispy.visuals.mesh import MeshVisual
+from vispy.visuals.filters import WireframeFilter
+
+
+def test_empty_mesh_wireframe():
+    """Test that an empty mesh does not cause issues with wireframe filter"""
+    mesh = MeshVisual()
+    wf = WireframeFilter()
+    mesh.attach(wf)
+
+    # trigger update of filter
+    wf.enabled = True

vispy/visuals/glsl/__init__.py

@@ -0,0 +1 @@
+"""Repository of common GLSL functions."""

vispy/visuals/glsl/antialiasing.py

@@ -0,0 +1,133 @@
+# Copyright (c) 2014, Nicolas P. Rougier. All Rights Reserved.
+# Distributed under the (new) BSD License.
+
+"""Antialiasing GLSL functions."""
+
+
+# -----------------------------------------------------------------------------
+# Stroke
+# -----------------------------------------------------------------------------
+
+"""Compute antialiased fragment color for a stroke line.
+
+Inputs:
+
+- distance (float): Signed distance to border (in pixels).
+
+
+Template variables:
+
+- linewidth (float): Stroke line width (in pixels).
+- antialias (float): Stroke antialiased area (in pixels).
+- stroke (vec4): Stroke color.
+
+
+Outputs:
+
+- color (vec4): The final color.
+
+"""
+ANTIALIAS_STROKE = """
+vec4 stroke(float distance)
+{
+    vec4 frag_color;
+    float t = $linewidth/2.0 - $antialias;
+    float signed_distance = distance;
+    float border_distance = abs(signed_distance) - t;
+    float alpha = border_distance/$antialias;
+    alpha = exp(-alpha*alpha);
+
+    if( border_distance < 0.0 )
+        frag_color = $stroke;
+    else
+        frag_color = vec4($stroke.rgb, $stroke.a * alpha);
+
+    return frag_color;
+}
+"""
+
+
+# -----------------------------------------------------------------------------
+# Stroke
+# -----------------------------------------------------------------------------
+
+"""Compute antialiased fragment color for an outlined shape.
+
+Inputs:
+
+- distance (float): Signed distance to border (in pixels).
+
+Template variables:
+
+- linewidth (float): Stroke line width (in pixels).
+- antialias (float): Stroke antialiased area (in pixels).
+- stroke (vec4): Stroke color.
+- fill (vec4): Fill color.
+
+Outputs:
+
+- color (vec4): The final color.
+
+"""
+ANTIALIAS_OUTLINE = """
+vec4 outline(float distance)
+{
+    vec4 frag_color;
+    float t = $linewidth/2.0 - $antialias;
+    float signed_distance = distance;
+    float border_distance = abs(signed_distance) - t;
+    float alpha = border_distance/$antialias;
+    alpha = exp(-alpha*alpha);
+
+    if( border_distance < 0.0 )
+        frag_color = $stroke;
+    else if( signed_distance < 0.0 )
+        frag_color = mix($fill, $stroke, sqrt(alpha));
+    else
+        frag_color = vec4($stroke.rgb, $stroke.a * alpha);
+    return frag_color;
+}
+"""
+
+
+# -----------------------------------------------------------------------------
+# Filled
+# -----------------------------------------------------------------------------
+
+"""Compute antialiased fragment color for a filled shape.
+
+Inputs:
+
+- distance (float): Signed distance to border (in pixels).
+
+Template variables:
+
+- linewidth (float): Stroke line width (in pixels).
+- antialias (float): Stroke antialiased area (in pixels).
+- fill (vec4): Fill color.
+
+Outputs:
+
+- color (vec4): The final color.
+
+"""
+ANTIALIAS_FILLED = """
+vec4 filled(float distance)
+{
+    vec4 frag_color;
+    float t = $linewidth/2.0 - $antialias;
+    float signed_distance = distance;
+    float border_distance = abs(signed_distance) - t;
+    float alpha = border_distance/$antialias;
+    alpha = exp(-alpha*alpha);
+
+    if( border_distance < 0.0 )
+        frag_color = $fill;
+    else if( signed_distance < 0.0 )
+        frag_color = $fill;
+    else
+        frag_color = vec4($fill.rgb, alpha * $fill.a);
+
+    return frag_color;
+}
+"""

vispy/visuals/glsl/color.py

@@ -0,0 +1,63 @@
+"""Color-related GLSL functions."""
+
+
+# -----------------------------------------------------------------------------
+# Colormaps
+# -----------------------------------------------------------------------------
+
+"""Texture lookup for a discrete color map stored in a 1*ncolors 2D texture.
+
+The `get_color()` function returns a RGB color from an index integer
+referring to the colormap.
+
+
+Inputs:
+
+- index (int): The color index.
+
+Template variables:
+
+- $ncolors (int): The number of colors in the colormap.
+- $colormap (2D texture sampler): The sampler for the 2D 1*ncolors colormap texture.
+
+Outputs:
+
+- color (vec3): The color.
+
+"""
+COLORMAP_TEXTURE = """
+vec3 get_color(int index) {
+    float x = (float(index) + .5) / float($ncolors);
+    return texture2D($colormap, vec2(x, .5)).rgb;
+}
+"""
+
+
+# -----------------------------------------------------------------------------
+# Color space transformations
+# -----------------------------------------------------------------------------
+
+# From http://lolengine.net/blog/2013/07/27/rgb-to-hsv-in-glsl
+# TODO: unit tests
+HSV_TO_RGB = """
+vec3 hsv_to_rgb(vec3 c)
+{
+    vec4 K = vec4(1.0, 2.0 / 3.0, 1.0 / 3.0, 3.0);
+    vec3 p = abs(fract(c.xxx + K.xyz) * 6.0 - K.www);
+    return c.z * mix(K.xxx, clamp(p - K.xxx, 0.0, 1.0), c.y);
+}
+"""
+
+
+RGB_TO_HSV = """
+vec3 rgb_to_hsv(vec3 c)
+{
+    vec4 K = vec4(0.0, -1.0 / 3.0, 2.0 / 3.0, -1.0);
+    vec4 p = mix(vec4(c.bg, K.wz), vec4(c.gb, K.xy), step(c.b, c.g));
+    vec4 q = mix(vec4(p.xyw, c.r), vec4(c.r, p.yzx), step(p.x, c.r));
+
+    float d = q.x - min(q.w, q.y);
+    float e = 1.0e-10;
+    return vec3(abs(q.z + (q.w - q.y) / (6.0 * d + e)), d / (q.x + e), q.x);
+}
+"""

vispy/visuals/graphs/__init__.py

@@ -0,0 +1 @@
+from .graph import GraphVisual  # noqa

vispy/visuals/graphs/graph.py

@@ -0,0 +1,240 @@
+# -*- coding: utf-8 -*-
+# Copyright (c) Vispy Development Team. All Rights Reserved.
+# Distributed under the (new) BSD License. See LICENSE.txt for more info.
+"""
+Graph Visual
+============
+
+This visual can be used to visualise graphs or networks.
+"""
+
+from ..visual import CompoundVisual
+from ..line import ArrowVisual
+from ..markers import MarkersVisual
+from . import layouts
+
+
+class GraphVisual(CompoundVisual):
+    """Visual for displaying graphs or networks.
+
+    Parameters
+    ----------
+    adjacency_mat : array or sparse
+        The adjacency matrix of the graph.
+    directed : bool
+        Whether the graph is directed or not. If True, then this visual will
+        draw arrows for the directed edges.
+    layout : str
+        They layout to use.
+    animate : bool
+        Whether or not to animate.
+    line_color : str or :class:`vispy.color.colormap.ColorMap`
+        The color to use for the edges.
+    line_width : number
+        The edge thickness.
+    arrow_type : str
+        The kind of arrow head to use. See :class:`vispy.visuals.ArrowHead`
+        for more information.
+    arrow_size : number
+        The size of the arrow head.
+    node_symbol : string
+        The marker to use for nodes. See
+        :class:`vispy.visuals.MarkersVisual` for more information.
+    node_size : number
+        The size of the node
+    border_color : str or :class:`vispy.color.colormap.ColorMap`
+        The border color for nodes.
+    face_color : str or :class:`vispy.color.colormap.ColorMap`
+        The face color for nodes.
+    border_width : number
+        The border size for nodes.
+
+    See Also
+    --------
+    ArrowVisual, MarkersVisual
+
+    """
+
+    _arrow_attributes = ('arrow_type', 'arrow_size')
+    _arrow_kwargs = ('line_color', 'line_width')
+    _node_kwargs = ('node_symbol', 'node_size', 'border_color', 'face_color',
+                    'border_width')
+
+    _arrow_kw_trans = dict(line_color='color', line_width='width')
+    _node_kw_trans = dict(node_symbol='symbol', node_size='size',
+                          border_color='edge_color', border_width='edge_width')
+    _node_properties_args = ()
+
+    def __init__(self, adjacency_mat=None, directed=False, layout=None,
+                 animate=False, line_color=None, line_width=None,
+                 arrow_type=None, arrow_size=None, node_symbol=None,
+                 node_size=None, border_color=None, face_color=None,
+                 border_width=None):
+
+        self._edges = ArrowVisual(method='gl', connect='segments')
+        self._nodes = MarkersVisual()
+
+        self._arrow_data = {}
+        self._node_data = {}
+        self._node_properties = {}
+
+        self._adjacency_mat = None
+
+        self._layout = None
+        self._layout_iter = None
+        self.layout = layout
+
+        self._directed = directed
+        self.directed = directed
+
+        self._animate = False
+        self.animate = animate
+
+        CompoundVisual.__init__(self, [self._edges, self._nodes])
+
+        self.set_data(adjacency_mat, line_color=line_color,
+                      line_width=line_width, arrow_type=arrow_type,
+                      arrow_size=arrow_size, node_symbol=node_symbol,
+                      node_size=node_size, border_color=border_color,
+                      face_color=face_color, border_width=border_width)
+
+    @property
+    def adjacency_matrix(self):
+        return self._adjacency_mat
+
+    @property
+    def layout(self):
+        return self._layout
+
+    @layout.setter
+    def layout(self, value):
+        if isinstance(value, str):
+            self._layout = layouts.get_layout(value)
+        else:
+            assert callable(value)
+            self._layout = value
+
+        self._layout_iter = None
+
+    @property
+    def directed(self):
+        return self._directed
+
+    @directed.setter
+    def directed(self, value):
+        self._directed = bool(value)
+
+    @property
+    def animate(self):
+        return self._animate
+
+    @animate.setter
+    def animate(self, value):
+        self._animate = bool(value)
+
+    def animate_layout(self):
+        if self._layout_iter is None:
+            if self._adjacency_mat is None:
+                raise ValueError("No adjacency matrix set yet. An adjacency "
+                                 "matrix is required to calculate the layout.")
+
+            self._layout_iter = iter(self._layout(self._adjacency_mat,
+                                                  self._directed))
+
+        try:
+            node_vertices, line_vertices, arrows = next(self._layout_iter)
+        except StopIteration:
+            return True
+
+        self._nodes.set_data(pos=node_vertices, **self._node_data)
+        for k, v in self._node_properties.items():
+            setattr(self._nodes, k, v)
+
+        self._edges.set_data(pos=line_vertices, arrows=arrows,
+                             **self._arrow_data)
+
+        return False
+
+    def set_final_layout(self):
+        if self._layout_iter is None:
+            if self._adjacency_mat is None:
+                raise ValueError("No adjacency matrix set yet. An adjacency "
+                                 "matrix is required to calculate the layout.")
+
+            self._layout_iter = iter(self._layout(self._adjacency_mat,
+                                                  self._directed))
+
+        # Calculate the final position of the nodes and lines
+        node_vertices = None
+        line_vertices = None
+        arrows = None
+        for node_vertices, line_vertices, arrows in self._layout_iter:
+            pass
+
+        self._nodes.set_data(pos=node_vertices, **self._node_data)
+        for k, v in self._node_properties.items():
+            setattr(self._nodes, k, v)
+
+        self._edges.set_data(pos=line_vertices, arrows=arrows,
+                             **self._arrow_data)
+
+    def reset_layout(self):
+        self._layout_iter = None
+
+    def set_data(self, adjacency_mat=None, **kwargs):
+        """Set the data
+
+        Parameters
+        ----------
+        adjacency_mat : ndarray | None
+            The adjacency matrix.
+        **kwargs : dict
+            Keyword arguments to pass to the arrows.
+        """
+        if adjacency_mat is not None:
+            if adjacency_mat.shape[0] != adjacency_mat.shape[1]:
+                raise ValueError("Adjacency matrix should be square.")
+
+            self._adjacency_mat = adjacency_mat
+
+        for k in self._arrow_attributes:
+            if k in kwargs:
+                translated = (self._arrow_kw_trans[k] if k in
+                              self._arrow_kw_trans else k)
+
+                setattr(self._edges, translated, kwargs.pop(k))
+
+        arrow_kwargs = {}
+        for k in self._arrow_kwargs:
+            if k in kwargs:
+                translated = (self._arrow_kw_trans[k] if k in
+                              self._arrow_kw_trans else k)
+
+                arrow_kwargs[translated] = kwargs.pop(k)
+
+        node_kwargs = {}
+        for k in self._node_kwargs:
+            if k in kwargs:
+                translated = (self._node_kw_trans[k] if k in
+                              self._node_kw_trans else k)
+
+                node_kwargs[translated] = kwargs.pop(k)
+
+        if len(kwargs) > 0:
+            raise TypeError("%s.set_data() got invalid keyword arguments: %s"
+                            % (self.__class__.__name__, list(kwargs.keys())))
+
+        # some attributes should be set as properties
+        node_properties = {}
+        for k, v in list(node_kwargs.items()):
+            if k in (self._node_properties_args):
+                node_properties[k] = node_kwargs.pop(k)
+
+        # The actual data is set in GraphVisual.animate_layout or
+        # GraphVisual.set_final_layout
+        self._arrow_data = arrow_kwargs
+        self._node_data = node_kwargs
+        self._node_properties = node_properties
+
+        if not self._animate:
+            self.set_final_layout()

vispy/visuals/graphs/layouts/__init__.py

@@ -0,0 +1,55 @@
+# -*- coding: utf-8 -*-
+# Copyright (c) Vispy Development Team. All Rights Reserved.
+# Distributed under the (new) BSD License. See LICENSE.txt for more info.
+
+import inspect
+
+from .random import random
+from .circular import circular
+from .force_directed import fruchterman_reingold
+from .networkx_layout import NetworkxCoordinates
+
+
+_layout_map = {
+    'random': random,
+    'circular': circular,
+    'force_directed': fruchterman_reingold,
+    'spring_layout': fruchterman_reingold,
+    "networkx_layout": NetworkxCoordinates,
+}
+
+AVAILABLE_LAYOUTS = tuple(_layout_map.keys())
+
+
+def get_layout(name, *args, **kwargs):
+    """
+    Retrieve a graph layout
+
+    Some graph layouts accept extra options. Please refer to their
+    documentation for more information.
+
+    Parameters
+    ----------
+    name : string
+        The name of the layout. The variable `AVAILABLE_LAYOUTS`
+        contains all available layouts.
+    *args
+        Positional arguments which are passed to the layout.
+    **kwargs
+        Keyword arguments which are passed to the layout.
+
+    Returns
+    -------
+    layout : callable
+        The callable generator which will calculate the graph layout
+    """
+    if name not in _layout_map:
+        raise KeyError("Graph layout '%s' not found. Should be one of %s"
+                       % (name, AVAILABLE_LAYOUTS))
+
+    layout = _layout_map[name]
+
+    if inspect.isclass(layout):
+        layout = layout(*args, **kwargs)
+
+    return layout

vispy/visuals/graphs/layouts/circular.py

@@ -0,0 +1,49 @@
+# -*- coding: utf-8 -*-
+# Copyright (c) Vispy Development Team. All Rights Reserved.
+# Distributed under the (new) BSD License. See LICENSE.txt for more info.
+"""
+Circular Layout
+===============
+
+This module contains several graph layouts which rely heavily on circles.
+"""
+
+import numpy as np
+
+from ..util import _straight_line_vertices, issparse
+
+
+def circular(adjacency_mat, directed=False):
+    """Places all nodes on a single circle.
+
+    Parameters
+    ----------
+    adjacency_mat : matrix or sparse
+        The graph adjacency matrix
+    directed : bool
+        Whether the graph is directed. If this is True, is will also
+        generate the vertices for arrows, which can be passed to an
+        ArrowVisual.
+
+    Yields
+    ------
+    (node_vertices, line_vertices, arrow_vertices) : tuple
+        Yields the node and line vertices in a tuple. This layout only yields a
+        single time, and has no builtin animation
+    """
+    if issparse(adjacency_mat):
+        adjacency_mat = adjacency_mat.tocoo()
+
+    num_nodes = adjacency_mat.shape[0]
+
+    t = np.linspace(0, 2 * np.pi, num_nodes, endpoint=False)
+
+    # Visual coordinate system is between 0 and 1, so generate a circle with
+    # radius 0.5 and center it at the point (0.5, 0.5).
+    node_coords = (0.5 * np.array([np.cos(t), np.sin(t)]) + 0.5).T
+    node_coords = node_coords.astype(np.float32)
+
+    line_vertices, arrows = _straight_line_vertices(adjacency_mat,
+                                                    node_coords, directed)
+
+    yield node_coords, line_vertices, arrows