vispy 0.14.0__cp311-cp311-macosx_11_0_arm64.whl

vispy/visuals/cube.py

@@ -0,0 +1,41 @@
+# -*- coding: utf-8 -*-
+# -----------------------------------------------------------------------------
+# Copyright (c) Vispy Development Team. All Rights Reserved.
+# Distributed under the (new) BSD License. See LICENSE.txt for more info.
+# -----------------------------------------------------------------------------
+
+import warnings
+from .box import BoxVisual
+
+
+class CubeVisual(BoxVisual):
+    """Visual that displays a cube or cuboid
+
+    Parameters
+    ----------
+    size : float or tuple
+        The size of the cuboid. A float gives a cube, whereas tuples may
+        specify the size of each axis (x, y, z) independently.
+    vertex_colors : ndarray
+        Same as for `MeshVisual` class. See `create_cube` for vertex ordering.
+    face_colors : ndarray
+        Same as for `MeshVisual` class. See `create_cube` for vertex ordering.
+    color : Color
+        The `Color` to use when drawing the cube faces.
+    edge_color : tuple or Color
+        The `Color` to use when drawing the cube edges. If `None`, then no
+        cube edges are drawn.
+    """
+
+    def __init__(self, size=1.0, vertex_colors=None, face_colors=None,
+                 color=(0.5, 0.5, 1, 1), edge_color=None, **kwargs):
+        warnings.warn("The CubeVisual is deprecated in favor of BoxVisual",
+                      DeprecationWarning, stacklevel=2)
+        if isinstance(size, tuple):
+            width, height, depth = size
+        else:
+            width = height = depth = size
+        BoxVisual.__init__(self, width=width, height=height, depth=depth,
+                           vertex_colors=vertex_colors,
+                           face_colors=face_colors, color=color,
+                           edge_color=edge_color, **kwargs)

vispy/visuals/ellipse.py

@@ -0,0 +1,163 @@
+# -*- coding: utf-8 -*-
+# Copyright (c) Vispy Development Team. All Rights Reserved.
+# Distributed under the (new) BSD License. See LICENSE.txt for more info.
+
+
+"""Simple ellipse visual based on PolygonVisual"""
+
+from __future__ import division
+
+import numpy as np
+from .polygon import PolygonVisual
+
+
+class EllipseVisual(PolygonVisual):
+    """
+    Displays a 2D ellipse
+
+    Parameters
+    ----------
+    center : array
+        Center of the ellipse
+    color : instance of Color
+        The face color to use.
+    border_color : instance of Color
+        The border color to use.
+    border_width: float
+        The width of the border in pixels
+        Line widths > 1px are only
+        guaranteed to work when using `border_method='agg'` method.
+    radius : float | tuple
+        Radius or radii of the ellipse
+        Defaults to  (0.1, 0.1)
+    start_angle : float
+        Start angle of the ellipse in degrees
+        Defaults to 0.
+    span_angle : float
+        Span angle of the ellipse in degrees
+        Defaults to 360.
+    num_segments : int
+        Number of segments to be used to draw the ellipse
+        Defaults to 100
+    **kwargs : dict
+        Keyword arguments to pass to `PolygonVisual`.
+    """
+
+    def __init__(self, center=None, color='black', border_color=None,
+                 border_width=1, radius=(0.1, 0.1), start_angle=0.,
+                 span_angle=360., num_segments=100, **kwargs):
+        self._center = center
+        self._radius = radius
+        self._start_angle = start_angle
+        self._span_angle = span_angle
+        self._num_segments = num_segments
+
+        # triangulation can be very slow
+        kwargs.setdefault('triangulate', False)
+        PolygonVisual.__init__(self, pos=None, color=color,
+                               border_color=border_color,
+                               border_width=border_width, **kwargs)
+
+        self._mesh.mode = "triangle_fan"
+        self._regen_pos()
+        self._update()
+
+    @staticmethod
+    def _generate_vertices(center, radius, start_angle, span_angle,
+                           num_segments):
+        if isinstance(radius, (list, tuple)):
+            if len(radius) == 2:
+                xr, yr = radius
+            else:
+                raise ValueError("radius must be float or 2 value tuple/list"
+                                 " (got %s of length %d)" % (type(radius),
+                                                             len(radius)))
+        else:
+            xr = yr = radius
+
+        start_angle = np.deg2rad(start_angle)
+
+        vertices = np.empty([num_segments + 2, 2], dtype=np.float32)
+
+        # split the total angle into num_segments instances
+        theta = np.linspace(start_angle,
+                            start_angle + np.deg2rad(span_angle),
+                            num_segments + 1)
+
+        # PolarProjection
+        vertices[1:, 0] = center[0] + xr * np.cos(theta)
+        vertices[1:, 1] = center[1] + yr * np.sin(theta)
+
+        # specify center point (not used in border)
+        vertices[0] = np.float32([center[0], center[1]])
+
+        return vertices
+
+    @property
+    def center(self):
+        """The center of the ellipse"""
+        return self._center
+
+    @center.setter
+    def center(self, center):
+        """The center of the ellipse"""
+        self._center = center
+        self._regen_pos()
+        self._update()
+
+    @property
+    def radius(self):
+        """The start radii of the ellipse."""
+        return self._radius
+
+    @radius.setter
+    def radius(self, radius):
+        self._radius = radius
+        self._regen_pos()
+        self._update()
+
+    @property
+    def start_angle(self):
+        """The start start_angle of the ellipse."""
+        return self._start_angle
+
+    @start_angle.setter
+    def start_angle(self, start_angle):
+        self._start_angle = start_angle
+        self._regen_pos()
+        self._update()
+
+    @property
+    def span_angle(self):
+        """The angular span of the ellipse."""
+        return self._span_angle
+
+    @span_angle.setter
+    def span_angle(self, span_angle):
+        self._span_angle = span_angle
+        self._regen_pos()
+        self._update()
+
+    @property
+    def num_segments(self):
+        """The number of segments in the ellipse."""
+        return self._num_segments
+
+    @num_segments.setter
+    def num_segments(self, num_segments):
+        num_segments = int(num_segments)
+        if num_segments < 1:
+            raise ValueError('EllipseVisual must consist of more than 1 '
+                             'segment')
+        self._num_segments = num_segments
+        self._regen_pos()
+        self._update()
+
+    def _regen_pos(self):
+        vertices = self._generate_vertices(center=self._center,
+                                           radius=self._radius,
+                                           start_angle=self._start_angle,
+                                           span_angle=self._span_angle,
+                                           num_segments=self._num_segments)
+        # don't use the center point
+        self._pos = vertices[1:]

vispy/visuals/filters/__init__.py

@@ -0,0 +1,10 @@
+# -*- coding: utf-8 -*-
+# Copyright (c) Vispy Development Team. All Rights Reserved.
+# Distributed under the (new) BSD License. See LICENSE.txt for more info.
+
+from .base_filter import Filter, PrimitivePickingFilter  # noqa
+from .clipper import Clipper  # noqa
+from .color import Alpha, ColorFilter, IsolineFilter, ZColormapFilter  # noqa
+from .picking import PickingFilter  # noqa
+from .markers import MarkerPickingFilter  # noqa
+from .mesh import TextureFilter, ShadingFilter, InstancedShadingFilter, WireframeFilter, FacePickingFilter  # noqa

vispy/visuals/filters/base_filter.py

@@ -0,0 +1,242 @@
+# -*- coding: utf-8 -*-
+# Copyright (c) Vispy Development Team. All Rights Reserved.
+# Distributed under the (new) BSD License. See LICENSE.txt for more info.
+
+from abc import ABCMeta, abstractmethod
+
+import numpy as np
+
+from vispy.gloo import VertexBuffer
+from ..shaders import Function
+
+
+class BaseFilter(object):
+    """Superclass for all filters."""
+
+    def _attach(self, visual):
+        """Called when a filter should be attached to a visual.
+
+        Parameters
+        ----------
+        visual : instance of BaseVisual
+            The visual that called this.
+        """
+        raise NotImplementedError(self)
+
+    def _detach(self, visual):
+        """Called when a filter should be detached from a visual.
+
+        Parameters
+        ----------
+        visual : instance of BaseVisual
+            The visual that called this.
+        """
+        raise NotImplementedError(self)
+
+
+class Filter(BaseFilter):
+    """Base class for all filters that use fragment and/or vertex shaders.
+
+    Parameters
+    ----------
+    vcode : str | Function | None
+        Vertex shader code. If None, ``vhook`` and ``vpos`` will
+        be ignored.
+    vhook : {'pre', 'post'}
+        Hook name to attach the vertex shader to.
+    vpos : int
+        Position in the hook to attach the vertex shader.
+    fcode : str | Function | None
+        Fragment shader code. If None, ``fhook`` and ``fpos`` will
+        be ignored.
+    fhook : {'pre', 'post'}
+        Hook name to attach the fragment shader to.
+    fpos : int
+        Position in the hook to attach the fragment shader.
+
+    Attributes
+    ----------
+    vshader : Function | None
+        Vertex shader.
+    fshader : Function | None
+        Fragment shader.
+    """
+
+    def __init__(self, vcode=None, vhook='post', vpos=5,
+                 fcode=None, fhook='post', fpos=5):
+        super(Filter, self).__init__()
+
+        if vcode is not None:
+            self.vshader = Function(vcode) if isinstance(vcode, str) else vcode
+            self._vexpr = self.vshader()
+            self._vhook = vhook
+            self._vpos = vpos
+        else:
+            self.vshader = None
+
+        if fcode is not None:
+            self.fshader = Function(fcode) if isinstance(fcode, str) else fcode
+            self._fexpr = self.fshader()
+            self._fhook = fhook
+            self._fpos = fpos
+        else:
+            self.fshader = None
+
+        self._attached = False
+
+    @property
+    def attached(self):
+        return self._attached
+
+    def _attach(self, visual):
+        """Called when a filter should be attached to a visual.
+
+        Parameters
+        ----------
+        visual : instance of Visual
+            The visual that called this.
+        """
+        if self.vshader:
+            hook = visual._get_hook('vert', self._vhook)
+            hook.add(self._vexpr, position=self._vpos)
+
+        if self.fshader:
+            hook = visual._get_hook('frag', self._fhook)
+            hook.add(self._fexpr, position=self._fpos)
+
+        self._attached = True
+        self._visual = visual
+
+    def _detach(self, visual):
+        """Called when a filter should be detached from a visual.
+
+        Parameters
+        ----------
+        visual : instance of Visual
+            The visual that called this.
+        """
+        if self.vshader:
+            hook = visual._get_hook('vert', self._vhook)
+            hook.remove(self._vexpr)
+
+        if self.fshader:
+            hook = visual._get_hook('frag', self._fhook)
+            hook.remove(self._fexpr)
+
+        self._attached = False
+        self._visual = None
+
+
+class PrimitivePickingFilter(Filter, metaclass=ABCMeta):
+    """Abstract base class for Visual-specific filters to implement a
+    primitive-picking mode.
+
+    Subclasses must (and usually only need to) implement
+    :py:meth:`_get_picking_ids`.
+    """
+
+    def __init__(self, fpos=9, *, discard_transparent=False):
+        # fpos is set to 9 by default to put it near the end, but before the
+        # default PickingFilter
+        vfunc = Function("""\
+            varying vec4 v_marker_picking_color;
+            void prepare_marker_picking() {
+                v_marker_picking_color = $ids;
+            }
+        """)
+        ffunc = Function("""\
+            varying vec4 v_marker_picking_color;
+            void marker_picking_filter() {
+                if ( $enabled != 1 ) {
+                    return;
+                }
+                if ( $discard_transparent == 1 && gl_FragColor.a == 0.0 ) {
+                    discard;
+                }
+                gl_FragColor = v_marker_picking_color;
+            }
+        """)
+
+        self._id_colors = VertexBuffer(np.zeros((0, 4), dtype=np.float32))
+        vfunc['ids'] = self._id_colors
+        self._n_primitives = 0
+        super().__init__(vcode=vfunc, fcode=ffunc, fpos=fpos)
+        self.enabled = False
+        self.discard_transparent = discard_transparent
+
+    @abstractmethod
+    def _get_picking_ids(self):
+        """Return a 1D array of picking IDs for the vertices in the visual.
+
+        Generally, this method should be implemented to:
+            1. Calculate the number of primitives in the visual (may be
+            persisted in `self._n_primitives`).
+            2. Calculate a range of picking ids for each primitive in the
+            visual. IDs should start from 1, reserving 0 for the background. If
+            primitives comprise multiple vertices (triangles), ids may need to
+            be repeated.
+
+        The return value should be an array of uint32 with shape
+        (num_vertices,).
+
+        If no change to the picking IDs is needed (for example, the number of
+        primitives has not changed), this method should return `None`.
+        """
+        raise NotImplementedError(self)
+
+    def _update_id_colors(self):
+        """Calculate the colors encoding the picking IDs for the visual.
+
+        For performance, this method will not update the id colors VertexBuffer
+        if :py:meth:`_get_picking_ids` returns `None`.
+        """
+        # this should remain untouched
+        ids = self._get_picking_ids()
+        if ids is not None:
+            id_colors = self._pack_ids_into_rgba(ids)
+            self._id_colors.set_data(id_colors)
+
+    @staticmethod
+    def _pack_ids_into_rgba(ids):
+        """Pack an array of uint32 primitive ids into float32 RGBA colors."""
+        if ids.dtype != np.uint32:
+            raise ValueError(f"ids must be uint32, got {ids.dtype}")
+
+        return np.divide(
+            ids.view(np.uint8).reshape(-1, 4),
+            255,
+            dtype=np.float32
+        )
+
+    def _on_data_updated(self, event=None):
+        if not self.attached:
+            return
+        self._update_id_colors()
+
+    @property
+    def enabled(self):
+        return self._enabled
+
+    @enabled.setter
+    def enabled(self, e):
+        self._enabled = bool(e)
+        self.fshader['enabled'] = int(self._enabled)
+        self._on_data_updated()
+
+    @property
+    def discard_transparent(self):
+        return self._discard_transparent
+
+    @discard_transparent.setter
+    def discard_transparent(self, d):
+        self._discard_transparent = bool(d)
+        self.fshader['discard_transparent'] = int(self._discard_transparent)
+
+    def _attach(self, visual):
+        super()._attach(visual)
+        visual.events.data_updated.connect(self._on_data_updated)
+        self._on_data_updated()
+
+    def _detach(self, visual):
+        visual.events.data_updated.disconnect(self._on_data_updated)
+        super()._detach(visual)

vispy/visuals/filters/clipper.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.
+
+from .base_filter import Filter
+from ..transforms import NullTransform
+from ...geometry import Rect
+
+
+class Clipper(Filter):
+    """Clips visual output to a rectangular region."""
+
+    FRAG_SHADER = """
+        void clip() {
+            vec4 pos = $fb_to_clip(gl_FragCoord);
+            if( pos.x < $view.x || pos.x > $view.y ||
+                pos.y < $view.z || pos.y > $view.w ) {
+                discard;
+            }
+        }
+    """
+
+    def __init__(self, bounds=(0, 0, 1, 1), transform=None):
+        super(Clipper, self).__init__(fcode=self.FRAG_SHADER,
+                                      fhook='pre', fpos=1)
+
+        self.bounds = bounds  # (x, y, w, h)
+        if transform is None:
+            transform = NullTransform()
+        self._transform = None
+        self.transform = transform
+
+    @property
+    def bounds(self):
+        """The clipping boundaries.
+
+        This must be a tuple (x, y, w, h) in a clipping coordinate system
+        that is defined by the `transform` property.
+        """
+        return self._bounds
+
+    @bounds.setter
+    def bounds(self, b):
+        self._bounds = Rect(b).normalized()
+        b = self._bounds
+        self.fshader['view'] = (b.left, b.right, b.bottom, b.top)
+
+    @property
+    def transform(self):
+        """The transform that maps from framebuffer coordinates to clipping
+        coordinates.
+        """
+        return self._transform
+
+    @transform.setter
+    def transform(self, tr):
+        if tr is self._transform:
+            return
+        self._transform = tr
+        self.fshader['fb_to_clip'] = tr

vispy/visuals/filters/clipping_planes.py

@@ -0,0 +1,122 @@
+# -*- 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 annotations
+
+from typing import Optional
+
+from functools import lru_cache
+
+import numpy as np
+
+from ..shaders import Function, Varying
+from .base_filter import Filter
+
+
+class PlanesClipper(Filter):
+    """Clips visual output based on arbitrary clipping planes.
+
+    Parameters
+    ----------
+    cliping_planes : ArrayLike
+        Each plane is defined by a position and a normal vector (magnitude is irrelevant). Shape: (n_planes, 2, 3)
+    coord_system : str
+        Coordinate system used by the clipping planes (see visuals.transforms.transform_system.py)
+
+    """
+
+    VERT_CODE = """
+    void clip() {
+        // pass position as varying for interpolation
+        $v_position = gl_Position;
+    }
+    """
+
+    FRAG_CODE = """
+    void clip() {
+        float distance_from_clip = $clip_with_planes($itransform($v_position).xyz);
+        if (distance_from_clip < 0.)
+            discard;
+    }
+    """
+
+    def __init__(self, clipping_planes: Optional[np.ndarray] = None, coord_system: str = 'scene'):
+        tr = ['visual', 'scene', 'document', 'canvas', 'framebuffer', 'render']
+        if coord_system not in tr:
+            raise ValueError(f'Invalid coordinate system {coord_system}. Must be one of {tr}.')
+        self._coord_system = coord_system
+
+        super().__init__(
+            vcode=Function(self.VERT_CODE), vhook='post', vpos=1,
+            fcode=Function(self.FRAG_CODE), fhook='pre', fpos=1,
+        )
+
+        # initialize clipping planes
+        self._clipping_planes = np.empty((0, 2, 3), dtype=np.float32)
+        self._clipping_planes_func = Function(self._build_clipping_planes_glsl(0))
+        self.fshader['clip_with_planes'] = self._clipping_planes_func
+
+        v_position = Varying('v_position', 'vec4')
+        self.vshader['v_position'] = v_position
+        self.fshader['v_position'] = v_position
+
+        self.clipping_planes = clipping_planes
+
+    @property
+    def coord_system(self) -> str:
+        """
+        Coordinate system used by the clipping planes (see visuals.transforms.transform_system.py)
+        """
+        # unsettable cause we can't update the transform after being attached
+        return self._coord_system
+
+    def _attach(self, visual):
+        super()._attach(visual)
+        self.fshader['itransform'] = visual.get_transform('render', self._coord_system)
+
+    @staticmethod
+    @lru_cache(maxsize=10)
+    def _build_clipping_planes_glsl(n_planes: int) -> str:
+        """Build the code snippet used to clip the volume based on self.clipping_planes."""
+        func_template = '''
+            float clip_planes(vec3 loc) {{
+                float distance_from_clip = 3.4e38; // max float
+                {clips};
+                return distance_from_clip;
+            }}
+        '''
+        # the vertex is considered clipped if on the "negative" side of the plane
+        clip_template = '''
+            vec3 relative_vec{idx} = loc - $clipping_plane_pos{idx};
+            float distance_from_clip{idx} = dot(relative_vec{idx}, $clipping_plane_norm{idx});
+            distance_from_clip = min(distance_from_clip{idx}, distance_from_clip);
+            '''
+        all_clips = []
+        for idx in range(n_planes):
+            all_clips.append(clip_template.format(idx=idx))
+        formatted_code = func_template.format(clips=''.join(all_clips))
+        return formatted_code
+
+    @property
+    def clipping_planes(self) -> np.ndarray:
+        """Get the set of planes used to clip the mesh.
+        Each plane is defined by a position and a normal vector (magnitude is irrelevant). Shape: (n_planes, 2, 3)
+        """
+        return self._clipping_planes
+
+    @clipping_planes.setter
+    def clipping_planes(self, value: Optional[np.ndarray]):
+        if value is None:
+            value = np.empty((0, 2, 3), dtype=np.float32)
+
+        # only recreate function if amount of clipping planes changes
+        if len(value) != len(self._clipping_planes):
+            self._clipping_planes_func = Function(self._build_clipping_planes_glsl(len(value)))
+            self.fshader['clip_with_planes'] = self._clipping_planes_func
+
+        self._clipping_planes = value
+
+        for idx, plane in enumerate(value):
+            self._clipping_planes_func[f'clipping_plane_pos{idx}'] = tuple(plane[0])
+            self._clipping_planes_func[f'clipping_plane_norm{idx}'] = tuple(plane[1])