vispy 0.15.0__cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl

vispy/visuals/image_complex.py

@@ -0,0 +1,130 @@
+from .image import ImageVisual, _APPLY_CLIM_FLOAT, _APPLY_GAMMA_FLOAT
+import numpy as np
+from .shaders import Function, FunctionChain
+
+# In a complex Image, the texture will be rg32f, where:
+# data.r contains the real component
+# data.g contains the imaginary component
+COMPLEX_TRANSFORMS = {
+    "real": "float cplx2float(vec4 data) { return data.r; }",
+    "imaginary": "float cplx2float(vec4 data) { return data.g; }",
+    "magnitude": "float cplx2float(vec4 data) { return length(vec2(data)); }",
+    "phase": "float cplx2float(vec4 data) { return atan(data.g, data.r); }",
+}
+CPU_COMPLEX_TRANSFORMS = {
+    "magnitude": np.abs,
+    "phase": np.angle,
+    "real": np.real,
+    "imaginary": np.imag,
+}
+
+
+class ComplexImageVisual(ImageVisual):
+    """:class:`~vispy.visuals.ImageVisual` subclass displaying a complex-valued image.
+
+    This class handles complex values by using an rg32f float texture behind the scenes,
+    storing the real component in the "r"  value and the imaginary in the "g" value.
+
+    Parameters
+    ----------
+    data : ndarray
+        Complex valued ImageVisual data.  Should be a two dimensional array with a dtype
+        of np.complex64 or np.complex128.
+    complex_mode : str
+        The mode used to convert the complex value in each pixel into a scalar:
+            * 'real': show only the real component.
+            * 'imaginary': show only the imaginary component.
+            * 'magnitude': show the magnitude (`np.abs`) of the complex value.
+            * 'phase': show the phase (`np.angle`) of the complex value.
+    """
+    COMPLEX_MODES = set(COMPLEX_TRANSFORMS)
+
+    def __init__(self, data=None, complex_mode="magnitude", **kwargs):
+        if complex_mode not in self.COMPLEX_MODES:
+            raise ValueError(
+                "complex_mode must be one of %s" % ", ".join(self.COMPLEX_MODES)
+            )
+        self._data_is_complex = np.iscomplexobj(data)
+        self._complex_mode = complex_mode
+
+        if kwargs.get("clim", "auto") == "auto" and self._data_is_complex:
+            kwargs["clim"] = self._calc_complex_clim(data)
+
+        kwargs["texture_format"] = "r32f" if self._data_is_complex else "r32f"
+        if self._data_is_complex:
+            data = self._convert_complex_to_float_view(data)
+        super().__init__(data=data, **kwargs)
+
+    def _init_texture(self, data, texture_format, **texture_kwargs):
+        texture_kwargs = {}
+        if self._data_is_complex:
+            texture_kwargs["format"] = "rg"
+        return super()._init_texture(data, texture_format, **texture_kwargs)
+
+    def set_data(self, image):
+        data = np.asarray(image)
+        if np.iscomplexobj(data):
+            #  Turn the texture into an rg32f texture
+            # where r = 'real' and g = 'imag'
+            self._data_is_complex = True
+            # FUTURE: Add formal way of defining texture format from set_data
+            self._texture._format = "rg"
+            data = self._convert_complex_to_float_view(data)
+        elif data.ndim == 3 and data.shape[-1] == 2:
+            # data was complex but was already converted to 32-bit float
+            # should really only occur from __init__
+            self._data_is_complex = True
+        else:
+            self._texture._format = None
+        return super().set_data(data)
+
+    @staticmethod
+    def _convert_complex_to_float_view(complex_arr):
+        # turn complex128 into complex64 if needed
+        complex64_arr = complex_arr.astype(np.complex64, copy=False)
+        float_view_arr = complex64_arr.view(dtype=np.float32).reshape((complex64_arr.shape + (2, )))
+        return float_view_arr
+
+    @property
+    def complex_mode(self):
+        return self._data_is_complex and self._complex_mode
+
+    @complex_mode.setter
+    def complex_mode(self, value):
+        if value not in self.COMPLEX_MODES:
+            raise ValueError(
+                "complex_mode must be one of %s" % ", ".join(self.COMPLEX_MODES)
+            )
+        if self._complex_mode != value:
+            self._complex_mode = value
+            self._need_colortransform_update = True
+            self.update()
+
+    def _build_color_transform(self):
+        if self.complex_mode:
+            fclim = Function(_APPLY_CLIM_FLOAT)
+            fgamma = Function(_APPLY_GAMMA_FLOAT)
+            chain = [
+                Function(COMPLEX_TRANSFORMS[self.complex_mode]),
+                fclim,
+                fgamma,
+                Function(self.cmap.glsl_map),
+            ]
+            fun = FunctionChain(None, chain)
+            fclim["clim"] = self._texture.clim_normalized
+            fgamma["gamma"] = self.gamma
+            return fun
+        return super()._build_color_transform()
+
+    @ImageVisual.clim.setter
+    def clim(self, clim):
+        if clim == "auto" and self.complex_mode:
+            clim = self._calc_complex_clim()
+        super(ComplexImageVisual, type(self)).clim.fset(self, clim)
+
+    def _calc_complex_clim(self, data=None):
+        # it would be nice if this could be done in the scalable texture mixin,
+        # but that would require the mixin knowing about the complex mode.
+        func = CPU_COMPLEX_TRANSFORMS[self.complex_mode]
+        _rendered = func(self._data if data is None else data)
+        return (_rendered.min(), _rendered.max())

vispy/visuals/infinite_line.py

@@ -0,0 +1,199 @@
+import numpy as np
+
+from .. import gloo
+from .visual import Visual
+
+
+_VERTEX_SHADER = """
+    attribute vec2 a_pos;
+    varying vec4 v_color;
+
+    void main() {
+        vec4 pos = vec4(a_pos, 0., 1.);
+
+        if($is_vertical==1)
+        {
+            pos.y = $render_to_visual(pos).y;
+        }
+        else
+        {
+            pos.x = $render_to_visual(pos).x;
+        }
+
+        gl_Position = $transform(pos);
+        gl_PointSize = 10.;
+        v_color = $color;
+    }
+    """
+
+_FRAGMENT_SHADER = """
+    varying vec4 v_color;
+
+    void main() {
+        gl_FragColor = v_color;
+    }
+    """
+
+
+class InfiniteLineVisual(Visual):
+    """Infinite horizontal or vertical line for 2D plots.
+
+    Parameters
+    ----------
+    pos : float
+        Position of the line along the axis.
+    color : list, tuple, or array
+        The color to use when drawing the line. If an array is given, it
+        must be of shape (1, 4) and provide one rgba color per vertex.
+    line_width: float
+        The width of the Infinite line, in pixels
+    antialias: bool
+        If the line is drawn with antialiasing
+    vertical:
+        True for drawing a vertical line, False for an horizontal line
+    """
+
+    _shaders = {
+        'vertex': _VERTEX_SHADER,
+        'fragment': _FRAGMENT_SHADER,
+    }
+
+    def __init__(self, pos=None, color=(1.0, 1.0, 1.0, 1.0), line_width=1.0, antialias=False,
+                 vertical=True, **kwargs):
+        """
+
+        """
+        Visual.__init__(self, vcode=self._shaders['vertex'], fcode=self._shaders['fragment'])
+
+        self._changed = {'pos': False, 'color': False}
+
+        self.pos_buf = gloo.VertexBuffer()
+        # The Visual superclass contains a MultiProgram, which is an object
+        # that behaves like a normal shader program (you can assign shader
+        # code, upload values, set template variables, etc.) but internally
+        # manages multiple ModularProgram instances, one per view.
+
+        # The MultiProgram is accessed via the `shared_program` property, so
+        # the following modifications to the program will be applied to all
+        # views:
+        self.shared_program['a_pos'] = self.pos_buf
+        self._program.vert['is_vertical'] = 1 if vertical else 0
+
+        self._need_upload = False
+        self._is_vertical = bool(vertical)
+        self._pos = np.zeros((2, 2), dtype=np.float32)
+        self._color = np.ones(4, dtype=np.float32)
+        self._line_width = line_width
+        self._antialias = antialias
+
+        # Visual keeps track of draw mode, index buffer, and GL state. These
+        # are shared between all views.
+        self._draw_mode = 'line_strip'
+        self.set_gl_state('translucent', depth_test=False)
+
+        self.set_data(pos=pos, color=color)
+
+    def set_data(self, pos=None, color=None):
+        """Set the data
+
+        Parameters
+        ----------
+        pos : float
+            Position of the line along the axis.
+        color : list, tuple, or array
+            The color to use when drawing the line. If an array is given, it
+            must be of shape (1, 4) and provide one rgba color per vertex.
+        """
+        if pos is not None:
+            pos = float(pos)
+            xy = self._pos
+            if self._is_vertical:
+                xy[0, 0] = pos
+                xy[0, 1] = -1
+                xy[1, 0] = pos
+                xy[1, 1] = 1
+            else:
+                xy[0, 0] = -1
+                xy[0, 1] = pos
+                xy[1, 0] = 1
+                xy[1, 1] = pos
+            self._changed['pos'] = True
+
+        if color is not None:
+            color = np.array(color, dtype=np.float32)
+            if color.ndim != 1 or color.shape[0] != 4:
+                raise ValueError('color must be a 4 element float rgba tuple,'
+                                 ' list or array')
+            self._color = color
+            self._changed['color'] = True
+
+    @property
+    def color(self):
+        return self._color
+
+    @property
+    def pos(self):
+        if self._is_vertical:
+            return self._pos[0, 0]
+        else:
+            return self._pos[0, 1]
+
+    @property
+    def line_width(self):
+        return self._line_width
+
+    @line_width.setter
+    def line_width(self, val: float):
+        self._line_width = val
+
+    @property
+    def antialias(self):
+        return self._antialias
+
+    @antialias.setter
+    def antialias(self, val: float):
+        self._antialias = val
+
+    def _compute_bounds(self, axis, view):
+        """Return the (min, max) bounding values of this visual along *axis*
+        in the local coordinate system.
+        """
+        is_vertical = self._is_vertical
+        pos = self._pos
+        if axis == 0 and is_vertical:
+            return (pos[0, 0], pos[0, 0])
+        elif axis == 1 and not is_vertical:
+            return (self._pos[0, 1], self._pos[0, 1])
+
+        return None
+
+    @property
+    def is_vertical(self):
+        return self._is_vertical
+
+    def _prepare_transforms(self, view=None):
+        program = view.view_program
+        transforms = view.transforms
+        program.vert['render_to_visual'] = transforms.get_transform('render',
+                                                                    'visual')
+        program.vert['transform'] = transforms.get_transform('visual',
+                                                             'render')
+
+    def _prepare_draw(self, view=None):
+        """This method is called immediately before each draw.
+
+        The *view* argument indicates which view is about to be drawn.
+        """
+
+        self.update_gl_state(line_smooth=self._antialias)
+        px_scale = self.transforms.pixel_scale
+        width = px_scale * self._line_width
+        self.update_gl_state(line_width=max(width, 1.0))
+
+        if self._changed['pos']:
+            self.pos_buf.set_data(self._pos)
+            self._changed['pos'] = False
+
+        if self._changed['color']:
+            self._program.vert['color'] = self._color
+            self._changed['color'] = False

vispy/visuals/instanced_mesh.py

@@ -0,0 +1,152 @@
+# -*- coding: utf-8 -*-
+# -----------------------------------------------------------------------------
+# Copyright (c) Vispy Development Team. All Rights Reserved.
+# Distributed under the (new) BSD License. See LICENSE.txt for more info.
+# -----------------------------------------------------------------------------
+
+"""An instanced version of MeshVisual with arbitrary shifts, transforms, and colors."""
+
+from __future__ import division
+
+import numpy as np
+
+from ..gloo import VertexBuffer
+from ..gloo.texture import downcast_to_32bit_if_needed
+from ..color import ColorArray
+from .filters import InstancedShadingFilter
+from .shaders import Variable
+
+from .mesh import MeshVisual
+
+
+_VERTEX_SHADER = """
+uniform bool use_instance_colors;
+
+// these attributes will be defined on an instance basis
+attribute vec3 shift;
+attribute vec3 transform_x;
+attribute vec3 transform_y;
+attribute vec3 transform_z;
+
+varying vec4 v_base_color;
+void main() {
+
+    v_base_color = $color_transform($base_color);
+
+    // transform is generated from column vectors (new basis vectors)
+    // https://en.wikibooks.org/wiki/GLSL_Programming/Vector_and_Matrix_Operations#Constructors
+    mat3 instance_transform = mat3(transform_x, transform_y, transform_z);
+    vec3 pos_rotated = instance_transform * $to_vec4($position).xyz;
+    vec4 pos_shifted = $to_vec4(pos_rotated + shift);
+    gl_Position = $transform(pos_shifted);
+}
+"""
+
+
+class InstancedMeshVisual(MeshVisual):
+    """Instanced Mesh visual.
+
+    Mostly identical to MeshVisual, but additionally takes arrays of
+    of positions and transforms (optionally colors) to create multiple
+    instances of the mesh.
+
+    Instancing is a rendering technique that re-uses the same mesh data
+    by applying transformations to vertices and vertex data or textures,
+    wich can drastically improve performance compared to having many
+    simple MeshVisuals.
+
+    Parameters
+    ----------
+    instance_positions : (I, 3) array
+        Coordinates for each instance of the mesh.
+    instance_transforms : (I, 3, 3) array
+        Matrices for the transforms to apply to each instance.
+    instance_colors : ColorArray
+        Matrices of colors for each instance. Colors
+    *args : list
+        Positional arguments to pass to :class:`~vispy.visuals.mesh.MeshVisual`.
+    **kwargs : dict
+        Keyword arguments to pass to :class:`~vispy.visuals.mesh.MeshVisual`.
+
+    Examples
+    --------
+    See example `scene/instanced_mesh_visual.py` in the gallery.
+    """
+
+    _shaders = {
+        'vertex': _VERTEX_SHADER,
+        'fragment': MeshVisual._shaders['fragment'],
+    }
+
+    _shading_filter_class = InstancedShadingFilter
+
+    def __init__(self, *args, instance_positions, instance_transforms, instance_colors=None, **kwargs):
+        self._instance_positions = None
+        self._instance_positions_vbo = None
+        self._instance_transforms = None
+        self._instance_transforms_vbos = None
+        self._instance_colors = None
+        self._instance_colors_vbo = None
+        super().__init__(*args, **kwargs)
+        self.instance_positions = instance_positions
+        self.instance_transforms = instance_transforms
+        self.instance_colors = instance_colors
+
+    @property
+    def instance_positions(self):
+        return self._instance_positions
+
+    @instance_positions.setter
+    def instance_positions(self, pos):
+        pos = np.reshape(pos, (-1, 3))
+        if pos.ndim != 2 or pos.shape[-1] != 3:
+            raise ValueError(f'positions must be 3D coordinates, but provided data has shape {pos.shape}')
+        self._instance_positions = downcast_to_32bit_if_needed(pos, dtype=np.float32)
+        self._instance_positions_vbo = VertexBuffer(self._instance_positions, divisor=1)
+        self.mesh_data_changed()
+
+    @property
+    def instance_transforms(self):
+        return self._instance_transforms
+
+    @instance_transforms.setter
+    def instance_transforms(self, matrix):
+        matrix = np.reshape(matrix, (-1, 3, 3))
+        if matrix.ndim != 3 or matrix.shape[1:] != (3, 3):
+            raise ValueError(f'transforms must be an array of 3x3 matrices, but provided data has shape {matrix.shape}')
+        self._instance_transforms = downcast_to_32bit_if_needed(matrix, dtype=np.float32)
+        # copy if not c contiguous
+        self._instance_transforms_vbos = (
+            VertexBuffer(np.ascontiguousarray(self._instance_transforms[..., 0]), divisor=1),
+            VertexBuffer(np.ascontiguousarray(self._instance_transforms[..., 1]), divisor=1),
+            VertexBuffer(np.ascontiguousarray(self._instance_transforms[..., 2]), divisor=1),
+        )
+        self.mesh_data_changed()
+
+    @property
+    def instance_colors(self):
+        return self._instance_colors
+
+    @instance_colors.setter
+    def instance_colors(self, colors):
+        if colors is not None:
+            colors = ColorArray(colors)
+            self._instance_colors_vbo = VertexBuffer(colors.rgba, divisor=1)
+        else:
+            self._instance_colors_vbo = Variable('base_color', self._color.rgba)
+
+        self._instance_colors = colors
+        self.mesh_data_changed()
+
+    def _update_data(self):
+        with self.events.data_updated.blocker():
+            super()._update_data()
+
+        # set instance buffers
+        self.shared_program.vert['base_color'] = self._instance_colors_vbo
+        self.shared_program['transform_x'] = self._instance_transforms_vbos[0]
+        self.shared_program['transform_y'] = self._instance_transforms_vbos[1]
+        self.shared_program['transform_z'] = self._instance_transforms_vbos[2]
+        self.shared_program['shift'] = self._instance_positions_vbo
+
+        self.events.data_updated()

vispy/visuals/isocurve.py

@@ -0,0 +1,213 @@
+# -*- 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
+from ..geometry.isocurve import isocurve
+
+
+class IsocurveVisual(LineVisual):
+    """Displays an isocurve of a 2D scalar array.
+
+    Parameters
+    ----------
+    data : ndarray | None
+        2D scalar array.
+    levels : ndarray, shape (Nlev,) | None
+        The levels at which the isocurve is constructed from "*data*".
+    color_lev : Color, colormap name, tuple, list or array
+        The color to use when drawing the line. If a list is given, it
+        must be of shape (Nlev), if an array is given, it must be of
+        shape (Nlev, ...). and provide one color per level (rgba, colorname).
+    clim : tuple
+        (min, max) limits to apply when mapping level values through a
+        colormap.
+    **kwargs : dict
+        Keyword arguments to pass to `LineVisual`.
+    """
+
+    def __init__(self, data=None, levels=None, color_lev=None, clim=None,
+                 **kwargs):
+        self._data = None
+        self._levels = levels
+        self._color_lev = color_lev
+        self._clim = clim
+        self._need_color_update = True
+        self._need_level_update = True
+        self._need_recompute = True
+        self._level_min = None
+        self._data_is_uniform = False
+        self._lc = None
+        self._cl = None
+        self._li = None
+        self._connect = None
+        self._verts = None
+        kwargs['method'] = 'gl'
+        kwargs['antialias'] = False
+        LineVisual.__init__(self, **kwargs)
+        if data is not None:
+            self.set_data(data)
+
+    @property
+    def levels(self):
+        """The threshold at which the isocurve is constructed from the
+        2D data.
+        """
+        return self._levels
+
+    @levels.setter
+    def levels(self, levels):
+        self._levels = levels
+        self._need_level_update = True
+        self._need_recompute = True
+        self.update()
+
+    @property
+    def color(self):
+        return self._color_lev
+
+    @color.setter
+    def color(self, color):
+        self._color_lev = color
+        self._need_level_update = True
+        self._need_color_update = True
+        self.update()
+
+    def set_data(self, data):
+        """Set the scalar array data
+
+        Parameters
+        ----------
+        data : ndarray
+            A 2D array of scalar values. The isocurve is constructed to show
+            all locations in the scalar field equal to ``self.levels``.
+        """
+        self._data = data
+
+        if self._clim is None:
+            self._clim = (data.min(), data.max())
+
+        # sanity check,
+        # should we raise an error here, since no isolines can be drawn?
+        # for now, _prepare_draw returns False if no isoline can be drawn
+        if self._data.min() != self._data.max():
+            self._data_is_uniform = False
+        else:
+            self._data_is_uniform = True
+
+        self._need_recompute = True
+        self.update()
+
+    def _get_verts_and_connect(self, paths):
+        """Retrieve vertices and connects from given paths-list"""
+        verts = np.vstack(paths)
+        gaps = np.add.accumulate(np.array([len(x) for x in paths])) - 1
+        connect = np.ones(gaps[-1], dtype=bool)
+        connect[gaps[:-1]] = False
+        return verts, connect
+
+    def _compute_iso_line(self):
+        """Compute LineVisual vertices, connects and color-index"""
+        level_index = []
+        connects = []
+        verts = []
+
+        # calculate which level are within data range
+        # this works for now and the existing examples, but should be tested
+        # thoroughly also with the data-sanity check in set_data-function
+        choice = np.nonzero((self.levels > self._data.min()) &
+                            (self.levels < self._data.max()))
+        levels_to_calc = np.array(self.levels)[choice]
+
+        # save minimum level index
+        self._level_min = choice[0][0]
+
+        try:
+            from skimage.measure import find_contours
+        except ImportError:
+            find_contours = None
+
+        for level in levels_to_calc:
+            # if we use skimage isoline algorithm we need to add half a
+            # pixel in both (x,y) dimensions because isolines are aligned to
+            # pixel centers
+            if find_contours is not None:
+                contours = find_contours(self._data, level,
+                                         positive_orientation='high')
+                v, c = self._get_verts_and_connect(contours)
+                # swap row, column to column, row (x, y)
+                v[:, [0, 1]] = v[:, [1, 0]]
+                v += np.array([0.5, 0.5])
+            else:
+                paths = isocurve(self._data.astype(float).T, level,
+                                 extend_to_edge=True, connected=True)
+                v, c = self._get_verts_and_connect(paths)
+
+            level_index.append(v.shape[0])
+            connects.append(np.hstack((c, [False])))
+            verts.append(v)
+
+        self._li = np.hstack(level_index)
+        self._connect = np.hstack(connects)
+        self._verts = np.vstack(verts)
+
+    def _compute_iso_color(self):
+        """Compute LineVisual color from level index and corresponding color"""
+        level_color = []
+        colors = self._lc
+        for i, index in enumerate(self._li):
+            level_color.append(np.zeros((index, 4)) +
+                               colors[i+self._level_min])
+        self._cl = np.vstack(level_color)
+
+    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._clim[0], self._clim[1])
+            # map function expects (Nlev,1)!
+            colors = f_color_levs.map(lev[:, np.newaxis])
+
+        # broadcast to (nlev, 4) array
+        if len(colors) == 1:
+            colors = colors * np.ones((len(self._levels), 1))
+
+        # detect color_lev/levels 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 _prepare_draw(self, view):
+        if (self._data is None or self._levels is None or
+                self._color_lev is None or self._data_is_uniform):
+            return False
+
+        if self._need_level_update:
+            self._levels_to_colors()
+            self._need_level_update = False
+
+        if self._need_recompute:
+            self._compute_iso_line()
+            self._compute_iso_color()
+            LineVisual.set_data(self, pos=self._verts, connect=self._connect,
+                                color=self._cl)
+            self._need_recompute = False
+
+        if self._need_color_update:
+            self._compute_iso_color()
+            LineVisual.set_data(self, color=self._cl)
+            self._need_color_update = False
+
+        return LineVisual._prepare_draw(self, view)