vispy 0.15.0__cp312-cp312-macosx_10_13_x86_64.whl

vispy/visuals/gridlines.py

@@ -0,0 +1,161 @@
+# -*- 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 .image import ImageVisual
+from ..color import Color
+from .shaders import Function
+
+
+_GRID_COLOR = """
+uniform vec4 u_gridlines_bounds;
+uniform float u_border_width;
+
+vec4 grid_color(vec2 pos) {
+    vec4 px_pos = $map_to_doc(vec4(pos, 0, 1));
+    px_pos /= px_pos.w;
+
+    // Compute vectors representing width, height of pixel in local coords
+    vec4 local_pos = $map_doc_to_local(px_pos);
+    vec4 dx = $map_doc_to_local(px_pos + vec4(1.0, 0, 0, 0));
+    vec4 dy = $map_doc_to_local(px_pos + vec4(0, 1.0, 0, 0));
+    local_pos /= local_pos.w;
+    dx = dx / dx.w - local_pos;
+    dy = dy / dy.w - local_pos;
+
+    // Pixel length along each axis, rounded to the nearest power of 10
+    vec2 px = vec2(abs(dx.x) + abs(dy.x), abs(dx.y) + abs(dy.y));
+    float log10 = log(10.0);
+    float sx = pow(10.0, floor(log(px.x) / log10) + 1.) * $scale.x;
+    float sy = pow(10.0, floor(log(px.y) / log10) + 1.) * $scale.y;
+
+    float max_alpha = 0.6;
+    float x_alpha = 0.0;
+
+    if (mod(local_pos.x, 1000. * sx) < px.x) {
+        x_alpha = clamp(1. * sx/px.x, 0., max_alpha);
+    }
+    else if (mod(local_pos.x, 100. * sx) < px.x) {
+        x_alpha = clamp(.1 * sx/px.x, 0., max_alpha);
+    }
+    else if (mod(local_pos.x, 10. * sx) < px.x) {
+        x_alpha = clamp(0.01 * sx/px.x, 0., max_alpha);
+    }
+
+    float y_alpha = 0.0;
+    if (mod(local_pos.y, 1000. * sy) < px.y) {
+        y_alpha = clamp(1. * sy/px.y, 0., max_alpha);
+    }
+    else if (mod(local_pos.y, 100. * sy) < px.y) {
+        y_alpha = clamp(.1 * sy/px.y, 0., max_alpha);
+    }
+    else if (mod(local_pos.y, 10. * sy) < px.y) {
+        y_alpha = clamp(0.01 * sy/px.y, 0., max_alpha);
+    }
+
+    float alpha = (((log(max(x_alpha, y_alpha))/log(10.)) + 2.) / 3.);
+    if (alpha == 0.) {
+        discard;
+    }
+
+    if (any(lessThan(local_pos.xy + u_border_width / 2, u_gridlines_bounds.xz)) ||
+        any(greaterThan(local_pos.xy - u_border_width / 2, u_gridlines_bounds.yw))) {
+        discard;
+    }
+
+    if (any(lessThan(local_pos.xy - u_gridlines_bounds.xz, vec2(u_border_width / 2))) ||
+        any(lessThan(u_gridlines_bounds.yw - local_pos.xy, vec2(u_border_width / 2)))) {
+        alpha = 1;
+    }
+
+    return vec4($color.rgb, $color.a * alpha);
+}
+"""
+
+
+class GridLinesVisual(ImageVisual):
+    """Displays regularly spaced grid lines in any coordinate system and at
+    any scale.
+
+    Parameters
+    ----------
+    scale : tuple
+        The scale factors to apply when determining the spacing of grid lines.
+    color : Color
+        The base color for grid lines. The final color may have its alpha
+        channel modified.
+    grid_bounds : tuple or None
+        The lower and upper bound for each axis beyond which no grid is rendered.
+        In the form of (minx, maxx, miny, maxy).
+    border_width : float
+        Tickness of the border rendered at the bounds of the grid.
+    """
+
+    def __init__(self, scale=(1, 1), color='w',
+                 grid_bounds=None,
+                 border_width=2):
+        # todo: PlaneVisual should support subdivide/impostor methods from
+        # image and gridlines should inherit from plane instead.
+        self._grid_color_fn = Function(_GRID_COLOR)
+        self._grid_color_fn['color'] = Color(color).rgba
+        self._grid_color_fn['scale'] = scale
+        ImageVisual.__init__(self, method='impostor')
+        self.set_gl_state('additive', cull_face=False)
+        self.shared_program.frag['get_data'] = self._grid_color_fn
+        cfun = Function('vec4 null(vec4 x) { return x; }')
+        self.shared_program.frag['color_transform'] = cfun
+        self.unfreeze()
+        self.grid_bounds = grid_bounds
+        self.border_width = border_width
+        self.freeze()
+
+    @property
+    def grid_bounds(self):
+        return self._grid_bounds
+
+    @grid_bounds.setter
+    def grid_bounds(self, value):
+        if value is None:
+            value = (None,) * 4
+        grid_bounds = []
+        for i, v in enumerate(value):
+            if v is None:
+                if i % 2:
+                    v = -np.inf
+                else:
+                    v = np.inf
+            grid_bounds.append(v)
+        self.shared_program['u_gridlines_bounds'] = value
+        self._grid_bounds = grid_bounds
+        self.update()
+
+    @property
+    def border_width(self):
+        return self._border_width
+
+    @border_width.setter
+    def border_width(self, value):
+        self.shared_program['u_border_width'] = value
+        self._border_width = value
+        self.update()
+
+    @property
+    def size(self):
+        return (1, 1)
+
+    def _prepare_transforms(self, view):
+        fn = self._grid_color_fn
+        fn['map_to_doc'] = self.get_transform('visual', 'document')
+        fn['map_doc_to_local'] = self.get_transform('document', 'visual')
+        ImageVisual._prepare_transforms(self, view)
+
+    def _prepare_draw(self, view):
+        if self._need_vertex_update:
+            self._build_vertex_data()
+
+        if view._need_method_update:
+            self._update_method(view)

vispy/visuals/gridmesh.py

@@ -0,0 +1,98 @@
+
+from .mesh import MeshVisual
+from ..geometry import create_grid_mesh, MeshData
+
+
+class GridMeshVisual(MeshVisual):
+    """Displays a mesh in a Cartesian grid about x,y,z coordinates.
+
+    This makes it simple to generate a mesh from e.g. the output
+    of numpy.meshgrid.
+
+    All arguments are optional, though they can be changed
+    individually later with the set_data method.
+
+    Parameters
+    ----------
+    xs : ndarray
+        A 2d array of x coordinates for the vertices of the mesh. Must
+        have the same dimensions as ys and zs.
+    ys : ndarray
+        A 2d array of y coordinates for the vertices of the mesh. Must
+        have the same dimensions as xs and zs.
+    zs : ndarray
+        A 2d array of z coordinates for the vertices of the mesh. Must
+        have the same dimensions as xs and ys.
+    colors : ndarray | None
+        The colors of the points of the mesh. Should be either a
+        (width, height, 4) array of rgba colors at each grid point or
+        a (width, height, 3) array of rgb colors at each grid point.
+        Defaults to None, in which case the default color of a
+        MeshVisual is used.
+    shading : str | None
+        Same as for the `MeshVisual` class. Defaults to 'smooth'.
+    **kwargs :
+        Other arguments are passed directly to MeshVisual.
+    """
+
+    def __init__(self, xs, ys, zs, colors=None, shading='smooth',
+                 **kwargs):
+
+        if xs is None or ys is None or zs is None:
+            raise ValueError('All of xs, ys and zs must be initialised '
+                             'with arrays.')
+
+        self._xs = None
+        self._ys = None
+        self._zs = None
+
+        self.__vertices = None
+        self.__meshdata = MeshData()
+
+        MeshVisual.__init__(self, shading=shading, **kwargs)
+        self.set_data(xs, ys, zs, colors)
+
+    def set_data(self, xs=None, ys=None, zs=None, colors=None):
+        """Update the mesh data.
+
+        Parameters
+        ----------
+        xs : ndarray | None
+            A 2d array of x coordinates for the vertices of the mesh.
+        ys : ndarray | None
+            A 2d array of y coordinates for the vertices of the mesh.
+        zs : ndarray | None
+            A 2d array of z coordinates for the vertices of the mesh.
+        colors : ndarray | None
+            The color at each point of the mesh. Must have shape
+            (width, height, 4) or (width, height, 3) for rgba or rgb
+            color definitions respectively.
+        """
+        if xs is None:
+            xs = self._xs
+            self.__vertices = None
+
+        if ys is None:
+            ys = self._ys
+            self.__vertices = None
+
+        if zs is None:
+            zs = self._zs
+            self.__vertices = None
+
+        if self.__vertices is None:
+            vertices, indices = create_grid_mesh(xs, ys, zs)
+            self._xs = xs
+            self._ys = ys
+            self._zs = zs
+
+        if self.__vertices is None:
+            vertices, indices = create_grid_mesh(self._xs, self._ys, self._zs)
+            self.__meshdata.set_vertices(vertices)
+            self.__meshdata.set_faces(indices)
+
+        if colors is not None:
+            self.__meshdata.set_vertex_colors(colors.reshape(
+                colors.shape[0] * colors.shape[1], colors.shape[2]))
+
+        MeshVisual.set_data(self, meshdata=self.__meshdata)

vispy/visuals/histogram.py

@@ -0,0 +1,58 @@
+# -*- 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 .mesh import MeshVisual
+
+
+class HistogramVisual(MeshVisual):
+    """Visual that calculates and displays a histogram of data
+
+    Parameters
+    ----------
+    data : array-like
+        Data to histogram. Currently only 1D data is supported.
+    bins : int | array-like
+        Number of bins, or bin edges.
+    color : instance of Color
+        Color of the histogram.
+    orientation : {'h', 'v'}
+        Orientation of the histogram.
+    """
+
+    def __init__(self, data, bins=10, color='w', orientation='h'):
+        #   4-5
+        #   | |
+        # 1-2/7-8
+        # |/| | |
+        # 0-3-6-9
+        data = np.asarray(data)
+        if data.ndim != 1:
+            raise ValueError('Only 1D data currently supported')
+        if not isinstance(orientation, str) or \
+                orientation not in ('h', 'v'):
+            raise ValueError('orientation must be "h" or "v", not %s'
+                             % (orientation,))
+        X, Y = (0, 1) if orientation == 'h' else (1, 0)
+
+        # do the histogramming
+        data, bin_edges = np.histogram(data, bins)
+        # construct our vertices
+        rr = np.zeros((3 * len(bin_edges) - 2, 3), np.float32)
+        rr[:, X] = np.repeat(bin_edges, 3)[1:-1]
+        rr[1::3, Y] = data
+        rr[2::3, Y] = data
+        bin_edges.astype(np.float32)
+        # and now our tris
+        tris = np.zeros((2 * len(bin_edges) - 2, 3), np.uint32)
+        offsets = 3 * np.arange(len(bin_edges) - 1,
+                                dtype=np.uint32)[:, np.newaxis]
+        tri_1 = np.array([0, 2, 1])
+        tri_2 = np.array([2, 0, 3])
+        tris[::2] = tri_1 + offsets
+        tris[1::2] = tri_2 + offsets
+        MeshVisual.__init__(self, rr, tris, color=color)