vispy 0.9.5__cp38-cp38-win_amd64.whl → 0.14.0__cp38-cp38-win_amd64.whl

vispy/visuals/filters/mesh.py

@@ -7,7 +7,7 @@ import numpy as np
 
 from vispy.gloo import Texture2D, VertexBuffer
 from vispy.visuals.shaders import Function, Varying
-from vispy.visuals.filters import Filter
+from vispy.visuals.filters import Filter, PrimitivePickingFilter
 from ...color import Color
 
 
@@ -177,6 +177,7 @@ void shade() {
         vec3 u = dFdx(v_pos_scene.xyz);
         vec3 v = dFdy(v_pos_scene.xyz);
         normal = cross(u, v);
+    } else {
         // Note(asnt): The normal calculated above always points in the
         // direction of the camera. Reintroduce the original orientation of the
         // face.
@@ -387,6 +388,10 @@ class ShadingFilter(Filter):
     <https://github.com/vispy/vispy/blob/main/examples/basics/scene/mesh_shading.py>`_
     example script.
     """
+    _shaders = {
+        'vertex': shading_vertex_template,
+        'fragment': shading_fragment_template,
+    }
 
     def __init__(self, shading='flat',
                  ambient_coefficient=(1, 1, 1, 1),
@@ -412,8 +417,8 @@ class ShadingFilter(Filter):
 
         self._enabled = enabled
 
-        vfunc = Function(shading_vertex_template)
-        ffunc = Function(shading_fragment_template)
+        vfunc = Function(self._shaders['vertex'])
+        ffunc = Function(self._shaders['fragment'])
 
         self._normals = VertexBuffer(np.zeros((0, 3), dtype=np.float32))
         vfunc['normal'] = self._normals
@@ -572,6 +577,29 @@ class ShadingFilter(Filter):
         super()._detach(visual)
 
 
+instanced_shading_vertex_template = shading_vertex_template.replace(
+    "$normal",
+    "mat3($instance_transform_x, $instance_transform_y, $instance_transform_z) * $normal"
+)
+
+
+class InstancedShadingFilter(ShadingFilter):
+    """Shading filter modified for use with :class:`~vispy.visuals.InstancedMeshVisual`.
+
+    See :class:`ShadingFilter` for details and usage.
+    """
+    _shaders = {
+        'vertex': instanced_shading_vertex_template,
+        'fragment': ShadingFilter._shaders['fragment'],
+    }
+
+    def _attach(self, visual):
+        super()._attach(visual)
+        self.vshader['instance_transform_x'] = visual._instance_transforms_vbos[0]
+        self.vshader['instance_transform_y'] = visual._instance_transforms_vbos[1]
+        self.vshader['instance_transform_z'] = visual._instance_transforms_vbos[2]
+
+
 wireframe_vertex_template = """
 varying vec3 v_bc;
 
@@ -729,13 +757,40 @@ class WireframeFilter(Filter):
         bc = np.tile(bc[None, ...], (n_faces, 1, 1))
         self._bc.set_data(bc, convert=True)
 
-    def on_mesh_data_updated(self, event):
+    def on_data_updated(self, event):
         self._update_data()
 
     def _attach(self, visual):
         super()._attach(visual)
-        visual.events.data_updated.connect(self.on_mesh_data_updated)
+        visual.events.data_updated.connect(self.on_data_updated)
 
     def _detach(self, visual):
-        visual.events.data_updated.disconnect(self.on_mesh_data_updated)
+        visual.events.data_updated.disconnect(self.on_data_updated)
         super()._detach(visual)
+
+
+class FacePickingFilter(PrimitivePickingFilter):
+    """Filter used to color mesh faces by a picking ID.
+
+    Note that the ID color uses the alpha channel, so this may not be used
+    with blending enabled.
+
+    Examples
+    --------
+    :ref:`sphx_glr_gallery_scene_face_picking.py`
+    """
+
+    def _get_picking_ids(self):
+        if self._visual.mesh_data.is_empty():
+            n_faces = 0
+        else:
+            n_faces = len(self._visual.mesh_data.get_faces())
+
+        # we only care about the number of faces changing
+        if self._n_primitives == n_faces:
+            return None
+        self._n_primitives = n_faces
+
+        ids = np.arange(1, n_faces + 1, dtype=np.uint32)
+        ids = np.repeat(ids, 3, axis=0)  # repeat id for each vertex
+        return ids

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/graphs/graph.py

@@ -63,7 +63,7 @@ class GraphVisual(CompoundVisual):
     _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 = ('symbol',)
+    _node_properties_args = ()
 
     def __init__(self, adjacency_mat=None, directed=False, layout=None,
                  animate=False, line_color=None, line_width=None,

vispy/visuals/image.py

@@ -5,10 +5,11 @@
 
 from __future__ import division
 
+import warnings
+
 import numpy as np
 
 from ..gloo import Texture2D, VertexBuffer
-from ..gloo.texture import should_cast_to_f32
 from ..color import get_colormap
 from .shaders import Function, FunctionChain
 from .transforms import NullTransform
@@ -129,6 +130,36 @@ _NULL_COLOR_TRANSFORM = 'vec4 pass(vec4 color) { return color; }'
 
 _C2L_RED = 'float cmap(vec4 color) { return color.r; }'
 
+_CUSTOM_FILTER = """
+vec4 texture_lookup(vec2 texcoord) {
+    // based on https://gist.github.com/kingbedjed/373c8811efcf1b3a155d29a13c1e5b61
+    vec2 tex_pixel = 1 / $shape;
+    vec2 kernel_pixel = 1 / $kernel_shape;
+    vec2 sampling_corner = texcoord - ($kernel_shape / 2 * tex_pixel);
+
+    // loop over kernel pixels
+    vec2 kernel_pos, tex_pos;
+    vec4 color = vec4(0);
+    float weight;
+
+    // offset 0.5 to sample center of pixels
+    for (float i = 0.5; i < $kernel_shape.x; i++) {
+        for (float j = 0.5; j < $kernel_shape.y; j++) {
+            kernel_pos = vec2(i, j) * kernel_pixel;
+            tex_pos = sampling_corner + vec2(i, j) * tex_pixel;
+            // TODO: allow other edge effects, like mirror or wrap
+            if (tex_pos.x >= 0 && tex_pos.y >= 0 && tex_pos.x <= 1 && tex_pos.y <= 1) {
+                weight = texture2D($kernel, kernel_pos).r;
+                // make sure to clamp or we sample outside
+                color += texture2D($texture, clamp(tex_pos, 0, 1)) * weight;
+            }
+        }
+    }
+
+    return color;
+}
+"""
+
 
 class ImageVisual(Visual):
     """Visual subclass displaying an image.
@@ -174,15 +205,16 @@ class ImageVisual(Visual):
         Gamma to use during colormap lookup.  Final color will be cmap(val**gamma).
         by default: 1.
     interpolation : str
-        Selects method of image interpolation. Makes use of the two Texture2D
+        Selects method of texture interpolation. Makes use of the two hardware
         interpolation methods and the available interpolation methods defined
         in vispy/gloo/glsl/misc/spatial_filters.frag
 
-            * 'nearest': Default, uses 'nearest' with Texture2D interpolation.
-            * 'bilinear': uses 'linear' with Texture2D interpolation.
-            * 'hanning', 'hamming', 'hermite', 'kaiser', 'quadric', 'bicubic',
+            * 'nearest': Default, uses 'nearest' with Texture interpolation.
+            * 'linear': uses 'linear' with Texture interpolation.
+            * 'hanning', 'hamming', 'hermite', 'kaiser', 'quadric', 'cubic',
                 'catrom', 'mitchell', 'spline16', 'spline36', 'gaussian',
                 'bessel', 'sinc', 'lanczos', 'blackman'
+            * 'custom': uses the sampling kernel provided through 'custom_kernel'.
     texture_format: numpy.dtype | str | None
         How to store data on the GPU. OpenGL allows for many different storage
         formats and schemes for the low-level texture data stored in the GPU.
@@ -204,6 +236,8 @@ class ImageVisual(Visual):
         GPU which allows for faster color limit changes. Additionally, when
         32-bit float data is provided it won't be copied before being
         transferred to the GPU.
+    custom_kernel: numpy.ndarray
+        Kernel used for texture sampling when interpolation is set to 'custom'.
     **kwargs : dict
         Keyword arguments to pass to `Visual`.
 
@@ -220,6 +254,7 @@ class ImageVisual(Visual):
 
     _func_templates = {
         'texture_lookup_interpolated': _INTERPOLATION_TEMPLATE,
+        'texture_lookup_custom': _CUSTOM_FILTER,
         'texture_lookup': _TEXTURE_LOOKUP,
         'clim_float': _APPLY_CLIM_FLOAT,
         'clim': _APPLY_CLIM,
@@ -231,7 +266,8 @@ class ImageVisual(Visual):
 
     def __init__(self, data=None, method='auto', grid=(1, 1),
                  cmap='viridis', clim='auto', gamma=1.0,
-                 interpolation='nearest', texture_format=None, **kwargs):
+                 interpolation='nearest', texture_format=None,
+                 custom_kernel=np.ones((1, 1)), **kwargs):
         """Initialize image properties, texture storage, and interpolation methods."""
         self._data = None
 
@@ -287,43 +323,54 @@ class ImageVisual(Visual):
         self.clim = clim or "auto"  # None -> "auto"
         self.cmap = cmap
         self.gamma = gamma
+        self.custom_kernel = custom_kernel
+
         if data is not None:
             self.set_data(data)
         self.freeze()
 
     def _init_interpolation(self, interpolation_names):
-        # create interpolation shader functions for available
-        # interpolations
-        fun = [Function(self._func_templates['texture_lookup_interpolated'] % n)
+        # create interpolation shader functions for available interpolations
+        fun = [Function(self._func_templates['texture_lookup_interpolated'] % (n + '2D'))
                for n in interpolation_names]
         interpolation_names = [n.lower() for n in interpolation_names]
 
+        # add custom filter
+        fun.append(Function(self._func_templates['texture_lookup_custom']))
+        interpolation_names.append('custom')
+
         interpolation_fun = dict(zip(interpolation_names, fun))
         interpolation_names = tuple(sorted(interpolation_names))
 
-        # overwrite "nearest" and "bilinear" spatial-filters
+        # overwrite "nearest" and "linear" spatial-filters
         # with  "hardware" interpolation _data_lookup_fn
         hardware_lookup = Function(self._func_templates['texture_lookup'])
         interpolation_fun['nearest'] = hardware_lookup
-        interpolation_fun['bilinear'] = hardware_lookup
+        interpolation_fun['linear'] = hardware_lookup
+        # alias bilinear to linear and bicubic to cubic (but deprecate)
+        interpolation_names = interpolation_names + ('bilinear', 'bicubic')
         return interpolation_names, interpolation_fun
 
-    def _init_texture(self, data, texture_format):
-        if self._interpolation == 'bilinear':
+    def _init_texture(self, data, texture_format, **texture_kwargs):
+        if self._interpolation == 'linear':
             texture_interpolation = 'linear'
         else:
             texture_interpolation = 'nearest'
 
         if texture_format is None:
             tex = CPUScaledTexture2D(
-                data, interpolation=texture_interpolation)
+                data, interpolation=texture_interpolation,
+                **texture_kwargs
+            )
         else:
             tex = GPUScaledTexture2D(
                 data, internalformat=texture_format,
-                interpolation=texture_interpolation)
+                interpolation=texture_interpolation,
+                **texture_kwargs
+            )
         return tex
 
-    def set_data(self, image):
+    def set_data(self, image, copy=False):
         """Set the image data.
 
         Parameters
@@ -333,9 +380,11 @@ class ImageVisual(Visual):
         texture_format : str or None
 
         """
-        data = np.asarray(image)
-        if should_cast_to_f32(data.dtype):
-            data = data.astype(np.float32)
+        data = np.array(image, copy=copy)
+        if np.iscomplexobj(data):
+            raise TypeError(
+                "Complex data types not supported. Please use 'ComplexImage' instead"
+            )
         # can the texture handle this data?
         self._texture.check_data_format(data)
         if self._data is None or self._data.shape[:2] != data.shape[:2]:
@@ -443,24 +492,62 @@ class ImageVisual(Visual):
         """Get names of possible interpolation methods."""
         return self._interpolation_names
 
+    @property
+    def custom_kernel(self):
+        """Kernel used by 'custom' interpolation for texture sampling"""
+        return self._custom_kernel
+
+    @custom_kernel.setter
+    def custom_kernel(self, value):
+        value = np.asarray(value, dtype=np.float32)
+        if value.ndim != 2:
+            raise ValueError(f'kernel must have 2 dimensions; got {value.ndim}')
+        self._custom_kernel = value
+        self._custom_kerneltex = Texture2D(value, interpolation='nearest', internalformat='r32f')
+        if self._data_lookup_fn is not None and 'kernel' in self._data_lookup_fn:
+            self._data_lookup_fn['kernel'] = self._custom_kerneltex
+            self._data_lookup_fn['kernel_shape'] = value.shape[::-1]
+        self.update()
+
     # The interpolation code could be transferred to a dedicated filter
     # function in visuals/filters as discussed in #1051
     def _build_interpolation(self):
         """Rebuild the _data_lookup_fn for different interpolations."""
         interpolation = self._interpolation
+        # alias bilinear to linear
+        if interpolation == 'bilinear':
+            warnings.warn(
+                "'bilinear' interpolation is Deprecated. Use 'linear' instead.",
+                DeprecationWarning,
+                stacklevel=2,
+            )
+            interpolation = 'linear'
+        # alias bicubic to cubic
+        if interpolation == 'bicubic':
+            warnings.warn(
+                "'bicubic' interpolation is Deprecated. Use 'cubic' instead.",
+                DeprecationWarning,
+                stacklevel=2,
+            )
+            interpolation = 'cubic'
         self._data_lookup_fn = self._interpolation_fun[interpolation]
         self.shared_program.frag['get_data'] = self._data_lookup_fn
 
-        # only 'bilinear' uses 'linear' texture interpolation
-        if interpolation == 'bilinear':
+        # only 'linear' and 'custom' use 'linear' texture interpolation
+        if interpolation in ('linear', 'custom'):
             texture_interpolation = 'linear'
         else:
-            # 'nearest' (and also 'bilinear') doesn't use spatial_filters.frag
-            # so u_kernel and shape setting is skipped
             texture_interpolation = 'nearest'
-            if interpolation != 'nearest':
+
+        # 'nearest' (and also 'linear') doesn't use spatial_filters.frag
+        # so u_kernel and shape setting is skipped
+        if interpolation not in ('nearest', 'linear'):
+            self._data_lookup_fn['shape'] = self._data.shape[:2][::-1]
+            if interpolation == 'custom':
+                self._data_lookup_fn['kernel'] = self._custom_kerneltex
+                self._data_lookup_fn['kernel_shape'] = self._custom_kernel.shape[::-1]
+            else:
                 self.shared_program['u_kernel'] = self._kerneltex
-                self._data_lookup_fn['shape'] = self._data.shape[:2][::-1]
 
         if self._texture.interpolation != texture_interpolation:
             self._texture.interpolation = texture_interpolation
@@ -526,7 +613,8 @@ class ImageVisual(Visual):
         except RuntimeError:
             pre_clims = "auto"
         pre_internalformat = self._texture.internalformat
-        self._texture.scale_and_set_data(self._data)
+        # copy was already made on `set_data` if requested
+        self._texture.scale_and_set_data(self._data, copy=False)
         post_clims = self._texture.clim_normalized
         post_internalformat = self._texture.internalformat
         # color transform needs rebuilding if the internalformat was changed

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())