vispy 0.15.0__cp312-cp312-macosx_10_13_x86_64.whl

vispy/visuals/isoline.py

@@ -0,0 +1,241 @@
+# -*- coding: utf-8 -*-
+# Copyright (c) Vispy Development Team. All Rights Reserved.
+# Distributed under the (new) BSD License. See LICENSE.txt for more info.
+
+from __future__ import division
+
+import numpy as np
+
+from .line import LineVisual
+from ..color import ColorArray
+from ..color.colormap import _normalize, get_colormap
+
+
+def iso_mesh_line(vertices, tris, vertex_data, levels):
+    """Generate an isocurve from vertex data in a surface mesh.
+
+    Parameters
+    ----------
+    vertices : ndarray, shape (Nv, 3)
+        Vertex coordinates.
+    tris : ndarray, shape (Nf, 3)
+        Indices of triangular element into the vertices array.
+    vertex_data : ndarray, shape (Nv,)
+        data at vertex.
+    levels : ndarray, shape (Nl,)
+        Levels at which to generate an isocurve
+
+    Returns
+    -------
+    lines : ndarray, shape (Nvout, 3)
+        Vertex coordinates for lines points
+    connects : ndarray, shape (Ne, 2)
+        Indices of line element into the vertex array.
+    vertex_level: ndarray, shape (Nvout,)
+        level for vertex in lines
+
+    Notes
+    -----
+    Uses a marching squares algorithm to generate the isolines.
+    """
+    lines = None
+    connects = None
+    vertex_level = None
+    level_index = None
+    if not all([isinstance(x, np.ndarray) for x in (vertices, tris,
+                                                    vertex_data, levels)]):
+        raise ValueError('all inputs must be numpy arrays')
+    if vertices.shape[1] <= 3:
+        verts = vertices
+    elif vertices.shape[1] == 4:
+        verts = vertices[:, :-1]
+    else:
+        verts = None
+    if (verts is not None and tris.shape[1] == 3 and
+            vertex_data.shape[0] == verts.shape[0]):
+        edges = np.vstack((tris.reshape((-1)),
+                           np.roll(tris, -1, axis=1).reshape((-1)))).T
+        edge_datas = vertex_data[edges]
+        edge_coors = verts[edges].reshape(tris.shape[0]*3, 2, 3)
+        for lev in levels:
+            # index for select edges with vertices have only False - True
+            # or True - False at extremity
+            index = (edge_datas >= lev)
+            index = index[:, 0] ^ index[:, 1]  # xor calculation
+            # Selectect edge
+            edge_datas_Ok = edge_datas[index, :]
+            xyz = edge_coors[index]
+            # Linear interpolation
+            ratio = np.array([(lev - edge_datas_Ok[:, 0]) /
+                              (edge_datas_Ok[:, 1] - edge_datas_Ok[:, 0])])
+            point = xyz[:, 0, :] + ratio.T * (xyz[:, 1, :] - xyz[:, 0, :])
+            nbr = point.shape[0]//2
+            if connects is not None:
+                connect = np.arange(0, nbr*2).reshape((nbr, 2)) + \
+                    len(lines)
+                connects = np.append(connects, connect, axis=0)
+                lines = np.append(lines, point, axis=0)
+                vertex_level = np.append(vertex_level,
+                                         np.zeros(len(point)) +
+                                         lev)
+                level_index = np.append(level_index, np.array(len(point)))
+            else:
+                lines = point
+                connects = np.arange(0, nbr*2).reshape((nbr, 2))
+                vertex_level = np.zeros(len(point)) + lev
+                level_index = np.array(len(point))
+
+            vertex_level = vertex_level.reshape((vertex_level.size, 1))
+
+    return lines, connects, vertex_level, level_index
+
+
+class IsolineVisual(LineVisual):
+    """Isocurves of a tri mesh with data at vertices at different levels.
+
+    Parameters
+    ----------
+    vertices : ndarray, shape (Nv, 3) | None
+        Vertex coordinates.
+    tris : ndarray, shape (Nf, 3) | None
+        Indices into the vertex array.
+    data : ndarray, shape (Nv,) | None
+        scalar at vertices
+    levels : ndarray, shape (Nlev,) | None
+        The levels at which the isocurve is constructed from "data".
+    color_lev : Color, tuple, colormap name or array
+        The color to use when drawing the line. If an array is given, it
+        must be of shape (Nlev, 4) and provide one rgba color by level.
+    **kwargs : dict
+        Keyword arguments to pass to `LineVisual`.
+    """
+
+    def __init__(self, vertices=None, tris=None, data=None,
+                 levels=None, color_lev=None, **kwargs):
+        self._data = None
+        self._vertices = None
+        self._tris = None
+        self._levels = levels
+        self._color_lev = color_lev
+        self._need_color_update = True
+        self._need_recompute = True
+        self._v = None
+        self._c = None
+        self._vl = None
+        self._li = None
+        self._lc = None
+        self._cl = None
+        self._update_color_lev = False
+        kwargs['antialias'] = False
+        LineVisual.__init__(self, method='gl', **kwargs)
+        self.set_data(vertices=vertices, tris=tris, data=data)
+
+    @property
+    def levels(self):
+        """The threshold at which the isocurves are constructed from the data."""
+        return self._levels
+
+    @levels.setter
+    def levels(self, levels):
+        self._levels = levels
+        self._need_recompute = True
+        self.update()
+
+    @property
+    def data(self):
+        """The mesh data"""
+        return self._vertices, self._tris, self._data
+
+    def set_data(self, vertices=None, tris=None, data=None):
+        """Set the data
+
+        Parameters
+        ----------
+        vertices : ndarray, shape (Nv, 3) | None
+            Vertex coordinates.
+        tris : ndarray, shape (Nf, 3) | None
+            Indices into the vertex array.
+        data : ndarray, shape (Nv,) | None
+            scalar at vertices
+        """
+        # modifier pour tenier compte des None self._recompute = True
+        if data is not None:
+            self._data = data
+            self._need_recompute = True
+        if vertices is not None:
+            self._vertices = vertices
+            self._need_recompute = True
+        if tris is not None:
+            self._tris = tris
+            self._need_recompute = True
+        self.update()
+
+    @property
+    def color(self):
+        return self._color_lev
+
+    def set_color(self, color):
+        """Set the color
+
+        Parameters
+        ----------
+        color : instance of Color
+            The color to use.
+        """
+        if color is not None:
+            self._color_lev = color
+            self._need_color_update = True
+            self.update()
+
+    def _levels_to_colors(self):
+        # computes ColorArrays for given levels
+        # try _color_lev as colormap, except as everything else
+        try:
+            f_color_levs = get_colormap(self._color_lev)
+        except (KeyError, TypeError):
+            colors = ColorArray(self._color_lev).rgba
+        else:
+            lev = _normalize(self._levels, self._levels.min(),
+                             self._levels.max())
+            # map function expects (Nlev,1)!
+            colors = f_color_levs.map(lev[:, np.newaxis])
+
+        if len(colors) == 1:
+            colors = colors * np.ones((len(self._levels), 1))
+
+        # detect color/level mismatch and raise error
+        if (len(colors) != len(self._levels)):
+            raise TypeError("Color/level mismatch. Color must be of shape "
+                            "(Nlev, ...) and provide one color per level")
+
+        self._lc = colors
+
+    def _compute_iso_color(self):
+        """Compute LineVisual color from level index and corresponding level color"""
+        level_color = []
+        colors = self._lc
+        for i, index in enumerate(self._li):
+            level_color.append(np.zeros((index, 4)) + colors[i])
+        self._cl = np.vstack(level_color)
+
+    def _prepare_draw(self, view):
+        if (self._data is None or self._levels is None or self._tris is None or
+                self._vertices is None or self._color_lev is None):
+            return False
+
+        if self._need_recompute:
+            self._v, self._c, self._vl, self._li = iso_mesh_line(
+                self._vertices, self._tris, self._data, self._levels)
+            self._levels_to_colors()
+            self._compute_iso_color()
+            LineVisual.set_data(self, pos=self._v, connect=self._c,
+                                color=self._cl)
+            self._need_recompute = False
+
+        if self._need_color_update:
+            self._levels_to_colors()
+            self._compute_iso_color()
+            LineVisual.set_data(self, color=self._cl)
+            self._update_color_lev = False
+
+        return LineVisual._prepare_draw(self, view)

vispy/visuals/isosurface.py

@@ -0,0 +1,113 @@
+# -*- coding: utf-8 -*-
+# Copyright (c) Vispy Development Team. All Rights Reserved.
+# Distributed under the (new) BSD License. See LICENSE.txt for more info.
+
+from __future__ import division
+
+from .mesh import MeshVisual
+from ..geometry.isosurface import isosurface
+from ..color import Color
+
+
+class IsosurfaceVisual(MeshVisual):
+    """Displays an isosurface of a 3D scalar array.
+
+    Parameters
+    ----------
+    data : ndarray | None
+        3D scalar array.
+    level: float | None
+        The level at which the isosurface is constructed from *data*.
+    vertex_colors : ndarray | None
+        The vertex colors to use.
+    face_colors : ndarray | None
+        The face colors to use.
+    color : ndarray | None
+        The color to use.
+    **kwargs : dict
+        Keyword arguments to pass to the mesh construction.
+    """
+
+    def __init__(self, data=None, level=None, vertex_colors=None,
+                 face_colors=None, color=(0.5, 0.5, 1, 1), **kwargs):
+        self._data = None
+        self._level = level
+        self._vertex_colors = vertex_colors
+        self._face_colors = face_colors
+        self._color = Color(color)
+
+        # We distinguish between recomputing and just changing the visual
+        # properties - in the latter case we don't recompute the faces.
+        self._vertices_cache = None
+        self._faces_cache = None
+        self._recompute = True
+        self._update_meshvisual = True
+
+        MeshVisual.__init__(self, **kwargs)
+        if data is not None:
+            self.set_data(data, vertex_colors=vertex_colors,
+                          face_colors=face_colors, color=color)
+
+    @property
+    def level(self):
+        """The threshold at which the isosurface is constructed from the 3D data."""
+        return self._level
+
+    @level.setter
+    def level(self, level):
+        self._level = level
+        self._recompute = True
+        self.update()
+
+    def set_data(self, data=None, vertex_colors=None, face_colors=None,
+                 color=None):
+        """Set the scalar array data
+
+        Parameters
+        ----------
+        data : ndarray
+            A 3D array of scalar values. The isosurface is constructed to show
+            all locations in the scalar field equal to ``self.level``.
+        vertex_colors : array-like | None
+            Colors to use for each vertex.
+        face_colors : array-like | None
+            Colors to use for each face.
+        color : instance of Color
+            The color to use.
+        """
+        # We only change the internal variables if they are provided
+        if data is not None:
+            self._data = data
+            self._recompute = True
+        if vertex_colors is not None:
+            self._vertex_colors = vertex_colors
+            self._update_meshvisual = True
+        if face_colors is not None:
+            self._face_colors = face_colors
+            self._update_meshvisual = True
+        if color is not None:
+            self._color = Color(color)
+            self._update_meshvisual = True
+        self.update()
+
+    def _prepare_draw(self, view):
+
+        if self._data is None or self._level is None:
+            return False
+
+        if self._recompute:
+            self._vertices_cache, self._faces_cache = isosurface(self._data,
+                                                                 self._level)
+            self._recompute = False
+            self._update_meshvisual = True
+
+        if self._update_meshvisual:
+            MeshVisual.set_data(self,
+                                vertices=self._vertices_cache,
+                                faces=self._faces_cache,
+                                vertex_colors=self._vertex_colors,
+                                face_colors=self._face_colors,
+                                color=self._color)
+            self._update_meshvisual = False
+
+        return MeshVisual._prepare_draw(self, view)

vispy/visuals/line/__init__.py

@@ -0,0 +1,6 @@
+# -*- coding: utf-8 -*-
+# Copyright (c) Vispy Development Team. All Rights Reserved.
+# Distributed under the (new) BSD License. See LICENSE.txt for more info.
+
+from .line import LineVisual  # noqa
+from .arrow import ArrowVisual  # noqa

vispy/visuals/line/arrow.py

@@ -0,0 +1,289 @@
+# -*- coding: utf-8 -*-
+# Copyright (c) Vispy Development Team. All Rights Reserved.
+# Distributed under the (new) BSD License. See LICENSE.txt for more info.
+"""
+Arrows are a subclass of line visuals, which adds the ability to put several
+heads on a line.
+"""
+
+from __future__ import division
+
+import numpy as np
+
+from ... import glsl, gloo
+from ..transforms._util import as_vec4
+from ..visual import Visual
+from .line import LineVisual
+
+
+ARROW_TYPES = (
+    'stealth',
+    'curved',
+    'angle_30',
+    'angle_60',
+    'angle_90',
+    'triangle_30',
+    'triangle_60',
+    'triangle_90',
+    'inhibitor_round'
+)
+
+
+class _ArrowHeadVisual(Visual):
+    """Arrow head visual
+
+    Several shapes to put on the end of a line. This visual differs from
+    MarkersVisual in the sense that this visual calculates the orientation of
+    the visual on the GPU, by calculating the tangent of the line between two
+    given vertices.
+
+    This is not really a visual you would use on your own,
+    use :class:`ArrowVisual` instead.
+
+    Parameters
+    ----------
+    parent : ArrowVisual
+        This actual ArrowVisual this arrow head is part of.
+    """
+
+    ARROWHEAD_VERTEX_SHADER = glsl.get('arrowheads/arrowheads.vert')
+    ARROWHEAD_FRAGMENT_SHADER = glsl.get('arrowheads/arrowheads.frag')
+
+    _arrow_vtype = np.dtype([
+        ('v1', np.float32, (4,)),
+        ('v2', np.float32, (4,)),
+        ('size', np.float32),
+        ('color', np.float32, (4,)),
+        ('linewidth', np.float32)
+    ])
+
+    def __init__(self, parent):
+        Visual.__init__(self, self.ARROWHEAD_VERTEX_SHADER,
+                        self.ARROWHEAD_FRAGMENT_SHADER)
+        self._parent = parent
+        self.set_gl_state(depth_test=False, blend=True,
+                          blend_func=('src_alpha', 'one_minus_src_alpha'))
+        self._draw_mode = 'points'
+
+        self._arrow_vbo = gloo.VertexBuffer(
+            np.array([], dtype=self._arrow_vtype))
+
+    def _prepare_transforms(self, view):
+        xform = view.transforms.get_transform()
+        view.view_program.vert['transform'] = xform
+
+    def _prepare_draw(self, view=None):
+        if self._parent._arrows_changed:
+            self._prepare_vertex_data()
+        self.shared_program.bind(self._arrow_vbo)
+        self.shared_program['antialias'] = 1.0
+        self.shared_program.frag['arrow_type'] = self._parent.arrow_type
+        self.shared_program.frag['fill_type'] = "filled"
+
+    def _prepare_vertex_data(self):
+        arrows = self._parent.arrows
+
+        if arrows is None or arrows.size == 0:
+            self._arrow_vbo = gloo.VertexBuffer(
+                np.array([], dtype=self._arrow_vtype))
+            return
+
+        v = np.zeros(len(arrows), dtype=self._arrow_vtype)
+        # 2d // 3d v1 v2.
+        sh = int(arrows.shape[1] / 2)
+        v['v1'] = as_vec4(arrows[:, 0:sh])
+        v['v2'] = as_vec4(arrows[:, sh:int(2 * sh)])
+        v['size'][:] = self._parent.arrow_size
+        color, cmap = self._parent._interpret_color(self._parent.arrow_color)
+        v['color'][:] = color
+        v['linewidth'][:] = self._parent.width
+        self._arrow_vbo = gloo.VertexBuffer(v)
+
+
+class ArrowVisual(LineVisual):
+    """Arrow visual
+
+    A special line visual which can also draw optional arrow heads at the
+    specified vertices.
+
+    You add an arrow head by specifying two vertices `v1` and `v2` which
+    represent the arrow body. This visual will draw an arrow head using `v2`
+    as center point, and the orientation of the arrow head is automatically
+    determined by calculating the direction vector between `v1` and `v2`. 
+    The arrow head can be detached from arrow body.
+
+    Parameters
+    ----------
+    pos : array
+        Array of shape (..., 2) or (..., 3) specifying vertex coordinates
+        of arrow body.
+    color : Color, tuple, or array
+        The color to use when drawing the line. If an array is given, it
+        must be of shape (..., 4) and provide one rgba color per vertex.
+        Can also be a colormap name, or appropriate `Function`.
+    width:
+        The width of the line in px. Line widths > 1px are only
+        guaranteed to work when using 'agg' method.
+    connect : str or array
+        Determines which vertices are connected by lines.
+
+            * "strip" causes the line to be drawn with each vertex
+              connected to the next.
+            * "segments" causes each pair of vertices to draw an
+              independent line segment
+            * numpy arrays specify the exact set of segment pairs to
+              connect.
+    method : str
+        Mode to use for drawing.
+
+            * "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.
+    antialias : bool
+        Enables or disables antialiasing.
+        For method='gl', this specifies whether to use GL's line smoothing,
+        which may be unavailable or inconsistent on some platforms.
+    arrows : array
+        A (N, 4) or (N, 6) matrix where each row contains the (x, y) or the
+        (x, y, z) coordinates of the first and second vertex of the arrow
+        head. Remember that the second vertex is used as center point for
+        the arrow head, and the first vertex is only used for determining
+        the arrow head orientation.
+    arrow_type : string
+        Specify the arrow head type, the currently available arrow head types
+        are:
+
+            * stealth
+            * curved
+            * triangle_30
+            * triangle_60
+            * triangle_90
+            * angle_30
+            * angle_60
+            * angle_90
+            * inhibitor_round
+    arrow_size : float
+        Specify the arrow size
+    arrow_color : Color, tuple, or array
+        The arrow head color. If an array is given, it must be of shape
+        (..., 4) and provide one rgba color per arrow head. Can also be a
+        colormap name, or appropriate `Function`.
+    """
+
+    def __init__(self, pos=None, color=(0.5, 0.5, 0.5, 1), width=1,
+                 connect='strip', method='gl', antialias=False, arrows=None,
+                 arrow_type='stealth', arrow_size=None,
+                 arrow_color=(0.5, 0.5, 0.5, 1)):
+
+        # Do not use the self._changed dictionary as it gets overwritten by
+        # the LineVisual constructor.
+        self._arrows_changed = False
+
+        self._arrow_type = None
+        self._arrow_size = None
+        self._arrows = None
+
+        self.arrow_type = arrow_type
+        self.arrow_size = arrow_size
+        self.arrow_color = arrow_color
+
+        self.arrow_head = _ArrowHeadVisual(self)
+
+        # TODO: `LineVisual.__init__` also calls its own `set_data` method,
+        # which triggers an *update* event. This results in a redraw. After
+        # that we call our own `set_data` method, which triggers another
+        # redraw. This should be fixed.
+        LineVisual.__init__(self, pos, color, width, connect, method,
+                            antialias)
+        ArrowVisual.set_data(self, arrows=arrows)
+
+        # Add marker visual for the arrow head
+        self.add_subvisual(self.arrow_head)
+
+    def set_data(self, pos=None, color=None, width=None, connect=None,
+                 arrows=None):
+        """Set the data used for this visual
+
+        Parameters
+        ----------
+        pos : array
+            Array of shape (..., 2) or (..., 3) specifying vertex coordinates.
+        color : Color, tuple, or array
+            The color to use when drawing the line. If an array is given, it
+            must be of shape (..., 4) and provide one rgba color per vertex.
+            Can also be a colormap name, or appropriate `Function`.
+        width:
+            The width of the line in px. Line widths > 1px are only
+            guaranteed to work when using 'agg' method.
+        connect : str or array
+            Determines which vertices are connected by lines.
+
+                * "strip" causes the line to be drawn with each vertex
+                  connected to the next.
+                * "segments" causes each pair of vertices to draw an
+                  independent line segment
+                * numpy arrays specify the exact set of segment pairs to
+                  connect.
+        arrows : array
+            A (N, 4) or (N, 6) matrix where each row contains the (x, y) or the
+            (x, y, z) coordinate of the first and second vertex of the arrow
+            body. Remember that the second vertex is used as center point for
+            the arrow head, and the first vertex is only used for determining
+            the arrow head orientation.
+        """
+        if arrows is not None:
+            self._arrows = arrows
+            self._arrows_changed = True
+
+        LineVisual.set_data(self, pos, color, width, connect)
+
+    @property
+    def arrow_type(self):
+        return self._arrow_type
+
+    @arrow_type.setter
+    def arrow_type(self, value):
+        if value not in ARROW_TYPES:
+            raise ValueError(
+                "Invalid arrow type '{}'. Should be one of {}".format(
+                    value, ", ".join(ARROW_TYPES)
+                )
+            )
+
+        if value == self._arrow_type:
+            return
+
+        self._arrow_type = value
+        self._arrows_changed = True
+
+    @property
+    def arrow_size(self):
+        return self._arrow_size
+
+    @arrow_size.setter
+    def arrow_size(self, value):
+        if value is None:
+            self._arrow_size = 5.0
+        else:
+            if value <= 0.0:
+                raise ValueError("Arrow size should be greater than zero.")
+
+            self._arrow_size = value
+
+        self._arrows_changed = True
+
+    @property
+    def arrow_color(self):
+        return self._arrow_color
+
+    @arrow_color.setter
+    def arrow_color(self, value):
+        if value is not None:
+            self._arrow_color = value
+            self._arrows_changed = True
+
+    @property
+    def arrows(self):
+        return self._arrows