vispy 0.15.0__cp313-cp313-win_amd64.whl

vispy/visuals/shaders/variable.py

@@ -0,0 +1,272 @@
+# -*- 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 .shader_object import ShaderObject
+
+VARIABLE_TYPES = ('const', 'uniform', 'attribute', 'varying', 'inout')
+
+
+class Variable(ShaderObject):
+    """Representation of global shader variable
+
+    Parameters
+    ----------
+    name : str
+        the name of the variable. This string can also contain the full
+        definition of the variable, e.g. 'uniform vec2 foo'.
+    value : {float, int, tuple, GLObject}
+        If given, vtype and dtype are determined automatically. If a
+        float/int/tuple is given, the variable is a uniform. If a gloo
+        object is given that has a glsl_type property, the variable is
+        an attribute and
+    vtype : {'const', 'uniform', 'attribute', 'varying', 'inout'}
+        The type of variable.
+    dtype : str
+        The data type of the variable, e.g. 'float', 'vec4', 'mat', etc.
+    """
+
+    _vtype_32_conversion = {'in': 'attribute', 'out': 'varying'}
+    _vtype_23_conversion = {'attribute': 'in', 'varying': 'out'}
+
+    def __init__(self, name, value=None, vtype=None, dtype=None):
+        super(Variable, self).__init__()
+
+        # allow full definition in first argument
+        if ' ' in name:
+            fields = name.split(' ')
+            if len(fields) == 3:
+                vtype, dtype, name = fields
+            elif len(fields) == 4 and fields[0] == 'const':
+                vtype, dtype, name, value = fields
+            else:
+                raise ValueError('Variable specifications given by string must'
+                                 ' be of the form "vtype dtype name" or '
+                                 '"const dtype name value".')
+
+        if not (isinstance(name, str) or name is None):
+            raise TypeError("Variable name must be string or None.")
+
+        self._state_counter = 0
+        self._name = name
+        self._vtype = self._vtype_32_conversion.get(vtype, vtype)
+        self._dtype = dtype
+        self._value = None
+
+        # If vtype/dtype were given at init, then we will never
+        # try to set these values automatically.
+        self._type_locked = self._vtype is not None and self._dtype is not None
+
+        if value is not None:
+            self.value = value
+
+        if self._vtype and self._vtype not in VARIABLE_TYPES:
+            raise ValueError('Not a valid vtype: %r' % self._vtype)
+
+    @property
+    def name(self):
+        """The name of this variable."""
+        return self._name
+
+    @name.setter
+    def name(self, n):
+        # Settable mostly to allow automatic setting of varying names
+        # See ShaderObject.create()
+        if self._name != n:
+            self._name = n
+            self.changed(code_changed=True)
+
+    @property
+    def vtype(self):
+        """The type of variable (const, uniform, attribute, or varying).
+
+        For in/out variables (GLSL 150+), vtype is 'varying'.
+        """
+        return self._vtype
+
+    @property
+    def dtype(self):
+        """The type of data (float, int, vec, mat, ...)."""
+        return self._dtype
+
+    @property
+    def value(self):
+        """The value associated with this variable."""
+        return self._value
+
+    @value.setter
+    def value(self, value):
+        if isinstance(value, (tuple, list)) and 1 < len(value) < 5:
+            vtype = 'uniform'
+            dtype = 'vec%d' % len(value)
+        elif isinstance(value, np.ndarray):
+            if value.ndim == 1 and (1 < len(value) < 5):
+                vtype = 'uniform'
+                dtype = 'vec%d' % len(value)
+            elif value.ndim == 2 and value.shape in ((2, 2), (3, 3), (4, 4)):
+                vtype = 'uniform'
+                dtype = 'mat%d' % value.shape[0]
+            else:
+                raise ValueError("Cannot make uniform value for %s from array "
+                                 "of shape %s." % (self.name, value.shape))
+        elif np.isscalar(value):
+            vtype = 'uniform'
+            if isinstance(value, (float, np.floating)):
+                dtype = 'float'
+            elif isinstance(value, (int, np.integer)):
+                dtype = 'int'
+            else:
+                raise TypeError("Unknown data type %r for variable %r" %
+                                (type(value), self))
+        elif getattr(value, 'glsl_type', None) is not None:
+            # Note: hasattr() is broken by design--swallows all exceptions!
+            vtype, dtype = value.glsl_type
+        else:
+            raise TypeError("Unknown data type %r for variable %r" %
+                            (type(value), self))
+
+        self._value = value
+        self._state_counter += 1
+
+        if self._type_locked:
+            if dtype != self._dtype or vtype != self._vtype:
+                raise TypeError('Variable is type "%s"; cannot assign value '
+                                '%r.' % (self.dtype, value))
+            return
+
+        # update vtype/dtype and emit changed event if necessary
+        changed = False
+        if self._dtype != dtype:
+            self._dtype = dtype
+            changed = True
+        if self._vtype != vtype:
+            self._vtype = vtype
+            changed = True
+        if changed:
+            self.changed(code_changed=True, value_changed=True)
+
+    @property
+    def state_id(self):
+        """Return a unique ID that changes whenever the state of the Variable
+        has changed. This allows ModularProgram to quickly determine whether
+        the value has changed since it was last used.
+        """
+        return id(self), self._state_counter
+
+    def __repr__(self):
+        return ("<%s \"%s %s %s\" at 0x%x>" % (self.__class__.__name__,
+                                               self._vtype, self._dtype,
+                                               self.name, id(self)))
+
+    def expression(self, names):
+        return names[self]
+
+    def _vtype_for_version(self, version):
+        """Return the vtype for this variable, converted based on the GLSL version."""
+        vtype = self.vtype
+        if version is None or version[0] == 120:
+            return self._vtype_32_conversion.get(vtype, vtype)
+        else:
+            return self._vtype_23_conversion.get(vtype, vtype)
+
+    def definition(self, names, version, shader):
+        if self.vtype is None:
+            raise RuntimeError("Variable has no vtype: %r" % self)
+        if self.dtype is None:
+            raise RuntimeError("Variable has no dtype: %r" % self)
+
+        name = names[self]
+        vtype = self._vtype_for_version(version)
+        if vtype == 'const':
+            return '%s %s %s = %s;' % (vtype, self.dtype, name, self.value)
+        else:
+            return '%s %s %s;' % (vtype, self.dtype, name)
+
+
+class Varying(Variable):
+    """Representation of a varying (variables passed from one shader to the
+    next).
+
+    Varyings can inherit their dtype from another Variable, allowing for
+    more flexibility in composing shaders.
+    """
+
+    def __init__(self, name, dtype=None):
+        self._link = None
+        self._src_func = None
+        self._dst_func = None
+        Variable.__init__(self, name, vtype='varying', dtype=dtype)
+
+    @property
+    def value(self):
+        """The value associated with this variable."""
+        return self._value
+
+    @value.setter
+    def value(self, value):
+        if value is not None:
+            raise TypeError("Cannot assign value directly to varying.")
+
+    @property
+    def dtype(self):
+        if self._dtype is None:
+            if self._link is None:
+                return None
+            else:
+                return self._link.dtype
+        else:
+            return self._dtype
+
+    def link(self, var):
+        """Link this Varying to another object from which it will derive its
+        dtype.
+
+        This method is used internally when assigning an attribute to
+        a varying using syntax ``function[varying] = attr``.
+        """
+        assert self._dtype is not None or hasattr(var, 'dtype')
+        self._link = var
+        self.changed()
+
+    def invar(self, array=False):
+        """Return a varying that defines itself using the same name as this,
+        but as an `in` variable instead of `out`.
+        """
+        return InVar(self, array=array)
+
+
+class InVar(Variable):
+    def __init__(self, var, array=False):
+        self._var = var
+        self._array = array
+        Variable.__init__(self, var.name)
+
+    @property
+    def value(self):
+        """The value associated with this variable."""
+        return self._var.value
+
+    @value.setter
+    def value(self, value):
+        if value is not None:
+            raise TypeError("Cannot assign value directly to varying.")
+
+    @property
+    def dtype(self):
+        return self._var.dtype
+
+    def definition(self, names, version, shader):
+        # inherit name from source variable
+        name = names[self._var]
+        dtype = self._var.dtype
+
+        if version[0] <= 120:
+            return "varying %s %s;" % (dtype, name)
+        else:
+            if self._array:
+                return "in %s %s[];" % (dtype, name)
+            else:
+                return "in %s %s;" % (dtype, name)
+
+    def expression(self, names):
+        return names[self._var]

vispy/visuals/spectrogram.py

@@ -0,0 +1,169 @@
+# -*- 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 .image import ImageVisual
+from ..util.fourier import stft, fft_freqs
+
+
+class SpectrogramVisual(ImageVisual):
+    """Calculate and show a spectrogram
+
+    Parameters
+    ----------
+    x : array-like
+        1D signal to operate on. ``If len(x) < n_fft``, x will be
+        zero-padded to length ``n_fft``.
+    n_fft : int
+        Number of FFT points. Much faster for powers of two.
+    step : int | None
+        Step size between calculations. If None, ``n_fft // 2``
+        will be used.
+    fs : float
+        The sample rate of the data.
+    window : str | None
+        Window function to use. Can be ``'hann'`` for Hann window, or None
+        for no windowing.
+    normalize : bool
+        Normalization of spectrogram values across frequencies.
+    color_scale : {'linear', 'log'}
+        Scale to apply to the result of the STFT.
+        ``'log'`` will use ``10 * log10(power)``.
+    cmap : str
+        Colormap name.
+    clim : str | tuple
+        Colormap limits. Should be ``'auto'`` or a two-element tuple of
+        min and max values.
+    """
+
+    def __init__(self, x=None, n_fft=256, step=None, fs=1., window='hann',
+                 normalize=False, color_scale='log', cmap='cubehelix',
+                 clim='auto'):
+        self._x = np.asarray(x)
+        self._n_fft = int(n_fft)
+        self._step = step
+        self._fs = float(fs)
+        self._window = window
+        self._normalize = normalize
+        self._color_scale = color_scale
+
+        if clim == 'auto':
+            self._clim_auto = True
+        else:
+            self._clim_auto = False
+
+        if not isinstance(self._color_scale, str) or \
+                self._color_scale not in ('log', 'linear'):
+            raise ValueError('color_scale must be "linear" or "log"')
+
+        data = self._calculate_spectrogram()
+        super(SpectrogramVisual, self).__init__(data, clim=clim, cmap=cmap)
+
+    @property
+    def freqs(self):
+        """The spectrogram frequencies"""
+        return fft_freqs(self._n_fft, self._fs)
+
+    @property
+    def x(self):
+        """The original signal"""
+        return self._x
+
+    @x.setter
+    def x(self, x):
+        self._x = np.asarray(x)
+        self._update_image()
+
+    @property
+    def n_fft(self):
+        """The length of fft window"""
+        return self._n_fft
+
+    @n_fft.setter
+    def n_fft(self, n_fft):
+        self._n_fft = int(n_fft)
+        self._update_image()
+
+    @property
+    def step(self):
+        """The step of fft window"""
+        if self._step is None:
+            return self._n_fft // 2
+        else:
+            return self._step
+
+    @step.setter
+    def step(self, step):
+        self._step = step
+        self._update_image()
+
+    @property
+    def fs(self):
+        """The sampling frequency"""
+        return self._fs
+
+    @fs.setter
+    def fs(self, fs):
+        self._fs = fs
+        self._update_image()
+
+    @property
+    def window(self):
+        """The used window function"""
+        return self._window
+
+    @window.setter
+    def window(self, window):
+        self._window = window
+        self._update_image()
+
+    @property
+    def color_scale(self):
+        """The color scale"""
+        return self._color_scale
+
+    @color_scale.setter
+    def color_scale(self, color_scale):
+        if not isinstance(color_scale, str) or \
+                color_scale not in ('log', 'linear'):
+            raise ValueError('color_scale must be "linear" or "log"')
+        self._color_scale = color_scale
+        self._update_image()
+
+    @property
+    def normalize(self):
+        """The normalization setting"""
+        return self._normalize
+
+    @normalize.setter
+    def normalize(self, normalize):
+        self._normalize = normalize
+        self._update_image()
+
+    def _calculate_spectrogram(self):
+        if self._x is not None:
+            x = self._x
+            nan_mean = np.nanmean(x)
+            idx = np.isnan(x)
+            x[idx] = nan_mean
+            data = stft(x, self._n_fft, self._step, self._fs, self._window)
+            data = np.abs(data)
+            data = 20 * np.log10(data) if self._color_scale == 'log' else data
+            if self._normalize:
+                for i in range(data.shape[0]):
+                    data[i, :] -= np.mean(data[i, :])
+                    data[i, :] /= np.std(data[i, :])
+            return data.astype(np.float32)  # ImageVisual will warn if 64-bit
+        else:
+            return None
+
+    def _update_image(self):
+        data = self._calculate_spectrogram()
+        self.set_data(data)
+        self.update()
+        if self._clim_auto:
+            self.clim = 'auto'

vispy/visuals/sphere.py

@@ -0,0 +1,80 @@
+# -*- coding: utf-8 -*-
+# -----------------------------------------------------------------------------
+# Copyright (c) Vispy Development Team. All Rights Reserved.
+# Distributed under the (new) BSD License. See LICENSE.txt for more info.
+# -----------------------------------------------------------------------------
+
+from ..geometry import create_sphere
+from .mesh import MeshVisual
+from .visual import CompoundVisual
+
+
+class SphereVisual(CompoundVisual):
+    """Visual that displays a sphere
+
+    Parameters
+    ----------
+    radius : float
+        The size of the sphere.
+    cols : int
+        Number of cols that make up the sphere mesh
+        (for method='latitude' and 'cube').
+    rows : int
+        Number of rows that make up the sphere mesh
+        (for method='latitude' and 'cube').
+    depth : int
+        Number of depth segments that make up the sphere mesh
+        (for method='cube').
+    subdivisions : int
+        Number of subdivisions to perform (for method='ico').
+    method : str
+        Method for generating sphere. Accepts 'latitude' for
+        latitude-longitude, 'ico' for icosahedron, and 'cube'
+        for cube based tessellation.
+    vertex_colors : ndarray
+        Same as for `MeshVisual` class.
+        See `create_sphere` for vertex ordering.
+    face_colors : ndarray
+        Same as for `MeshVisual` class.
+        See `create_sphere` for vertex ordering.
+    color : Color
+        The `Color` to use when drawing the sphere faces.
+    edge_color : tuple or Color
+        The `Color` to use when drawing the sphere edges. If `None`, then no
+        sphere edges are drawn.
+    shading : str | None
+        Shading to use.
+    """
+
+    def __init__(self, radius=1.0, cols=30, rows=30, depth=30, subdivisions=3,
+                 method='latitude', vertex_colors=None, face_colors=None,
+                 color=(0.5, 0.5, 1, 1), edge_color=None, shading=None, **kwargs):
+
+        mesh = create_sphere(rows, cols, depth, radius=radius,
+                             subdivisions=subdivisions, method=method)
+
+        self._mesh = MeshVisual(vertices=mesh.get_vertices(),
+                                faces=mesh.get_faces(),
+                                vertex_colors=vertex_colors,
+                                face_colors=face_colors, color=color,
+                                shading=shading)
+        if edge_color:
+            self._border = MeshVisual(vertices=mesh.get_vertices(),
+                                      faces=mesh.get_edges(),
+                                      color=edge_color, mode='lines')
+        else:
+            self._border = MeshVisual()
+
+        CompoundVisual.__init__(self, [self._mesh, self._border], **kwargs)
+        self.mesh.set_gl_state(polygon_offset_fill=True,
+                               polygon_offset=(1, 1), depth_test=True)
+
+    @property
+    def mesh(self):
+        """The vispy.visuals.MeshVisual that used to fil in."""
+        return self._mesh
+
+    @property
+    def border(self):
+        """The vispy.visuals.MeshVisual that used to draw the border."""
+        return self._border