ezmsg-sigproc 1.2.3__py3-none-any.whl → 1.3.1__py3-none-any.whl

ezmsg/sigproc/slicer.py

@@ -2,9 +2,12 @@ from dataclasses import replace
 import typing
 
 import numpy as np
+import numpy.typing as npt
 import ezmsg.core as ez
 from ezmsg.util.messages.axisarray import AxisArray, slice_along_axis
-from ezmsg.util.generator import consumer, GenAxisArray
+from ezmsg.util.generator import consumer
+
+from .base import GenAxisArray
 
 
 """
@@ -15,19 +18,20 @@ Slicer:Select a subset of data along a particular axis.
 def parse_slice(s: str) -> typing.Tuple[typing.Union[slice, int], ...]:
     """
     Parses a string representation of a slice and returns a tuple of slice objects.
-    * "" -> slice(None, None, None)  (take all)
-    * ":" -> slice(None, None, None)
-    * '"none"` (case-insensitive) -> slice(None, None, None)
-    * "{start}:{stop}" or {start}:{stop}:{step} -> slice(start, stop, step)
-    * "5" (or any integer) -> (5,). Take only that item.
+
+    - "" -> slice(None, None, None)  (take all)
+    - ":" -> slice(None, None, None)
+    - '"none"` (case-insensitive) -> slice(None, None, None)
+    - "{start}:{stop}" or {start}:{stop}:{step} -> slice(start, stop, step)
+    - "5" (or any integer) -> (5,). Take only that item.
         applying this to a ndarray or AxisArray will drop the dimension.
-    * A comma-separated list of the above -> a tuple of slices | ints
+    - A comma-separated list of the above -> a tuple of slices | ints
 
     Args:
-        s (str): The string representation of the slice.
+        s: The string representation of the slice.
 
     Returns:
-        tuple[slice | int, ...]: A tuple of slice objects and/or ints.
+        A tuple of slice objects and/or ints.
     """
     if s.lower() in ["", ":", "none"]:
         return (slice(None),)
@@ -36,51 +40,82 @@ def parse_slice(s: str) -> typing.Tuple[typing.Union[slice, int], ...]:
         if len(parts) == 1:
             return (int(parts[0]),)
         return (slice(*(int(part.strip()) if part else None for part in parts)),)
-    l = [parse_slice(_) for _ in s.split(",")]
-    return tuple([item for sublist in l for item in sublist])
+    suplist = [parse_slice(_) for _ in s.split(",")]
+    return tuple([item for sublist in suplist for item in sublist])
 
 
 @consumer
 def slicer(
     selection: str = "", axis: typing.Optional[str] = None
 ) -> typing.Generator[AxisArray, AxisArray, None]:
-    axis_arr_in = AxisArray(np.array([]), dims=[""])
-    axis_arr_out = AxisArray(np.array([]), dims=[""])
-    _slice = None
-    b_change_dims = False
+    msg_out = AxisArray(np.array([]), dims=[""])
+
+    # State variables
+    _slice: typing.Optional[typing.Union[slice, npt.NDArray]] = None
+    new_axis: typing.Optional[AxisArray.Axis] = None
+    b_change_dims: bool = False  # If number of dimensions changes when slicing
+
+    # Reset if input changes
+    check_input = {
+        "key": None,  # key change used as proxy for label change, which we don't check explicitly
+        "len": None,
+    }
 
     while True:
-        axis_arr_in = yield axis_arr_out
+        msg_in: AxisArray = yield msg_out
 
-        if axis is None:
-            axis = axis_arr_in.dims[-1]
-        axis_idx = axis_arr_in.get_axis_idx(axis)
+        axis = axis or msg_in.dims[-1]
+        axis_idx = msg_in.get_axis_idx(axis)
 
-        if _slice is None:
+        b_reset = _slice is None  # or new_axis is None
+        b_reset = b_reset or msg_in.key != check_input["key"]
+        b_reset = b_reset or (
+            (msg_in.data.shape[axis_idx] != check_input["len"])
+            and (type(_slice) is np.ndarray)
+        )
+        if b_reset:
+            check_input["key"] = msg_in.key
+            check_input["len"] = msg_in.data.shape[axis_idx]
+            new_axis = None  # Will hold updated metadata
+            b_change_dims = False
+
+            # Calculate the slice
             _slices = parse_slice(selection)
             if len(_slices) == 1:
                 _slice = _slices[0]
+                # Do we drop the sliced dimension?
                 b_change_dims = isinstance(_slice, int)
             else:
                 # Multiple slices, but this cannot be done in a single step, so we convert the slices
                 #  to a discontinuous set of integer indexes.
-                indices = np.arange(axis_arr_in.data.shape[axis_idx])
+                indices = np.arange(msg_in.data.shape[axis_idx])
                 indices = np.hstack([indices[_] for _ in _slices])
-                _slice = np.s_[indices]
-
+                _slice = np.s_[indices]  # Integer scalar array
+
+            # Create the output axis.
+            if (
+                axis in msg_in.axes
+                and hasattr(msg_in.axes[axis], "labels")
+                and len(msg_in.axes[axis].labels) > 0
+            ):
+                new_labels = msg_in.axes[axis].labels[_slice]
+                new_axis = replace(msg_in.axes[axis], labels=new_labels)
+
+        replace_kwargs = {}
         if b_change_dims:
-            out_dims = [_ for dim_ix, _ in enumerate(axis_arr_in.dims) if dim_ix != axis_idx]
-            out_axes = axis_arr_in.axes.copy()
-            out_axes.pop(axis, None)
-        else:
-            out_dims = axis_arr_in.dims
-            out_axes = axis_arr_in.axes
-
-        axis_arr_out = replace(
-            axis_arr_in,
-            dims=out_dims,
-            axes=out_axes,
-            data=slice_along_axis(axis_arr_in.data, _slice, axis_idx),
+            # Dropping the target axis
+            replace_kwargs["dims"] = [
+                _ for dim_ix, _ in enumerate(msg_in.dims) if dim_ix != axis_idx
+            ]
+            replace_kwargs["axes"] = {k: v for k, v in msg_in.axes.items() if k != axis}
+        elif new_axis is not None:
+            replace_kwargs["axes"] = {
+                k: (v if k != axis else new_axis) for k, v in msg_in.axes.items()
+            }
+        msg_out = replace(
+            msg_in,
+            data=slice_along_axis(msg_in.data, _slice, axis_idx),
+            **replace_kwargs,
         )
 
 
@@ -90,7 +125,7 @@ class SlicerSettings(ez.Settings):
 
 
 class Slicer(GenAxisArray):
-    SETTINGS: SlicerSettings
+    SETTINGS = SlicerSettings
 
     def construct_generator(self):
         self.STATE.gen = slicer(

ezmsg/sigproc/spectral.py

@@ -1,9 +1,6 @@
-from .spectrum import (
-    OptionsEnum,
-    WindowFunction,
-    SpectralTransform,
-    SpectralOutput,
-    SpectrumSettings,
-    SpectrumState,
-    Spectrum
-)
+from .spectrum import OptionsEnum as OptionsEnum
+from .spectrum import WindowFunction as WindowFunction
+from .spectrum import SpectralTransform as SpectralTransform
+from .spectrum import SpectralOutput as SpectralOutput
+from .spectrum import SpectrumSettings as SpectrumSettings
+from .spectrum import Spectrum as Spectrum

ezmsg/sigproc/spectrogram.py

@@ -1,16 +1,13 @@
 import typing
 
-import numpy as np
-
 import ezmsg.core as ez
 from ezmsg.util.messages.axisarray import AxisArray
-from ezmsg.util.generator import consumer, GenAxisArray  # , compose
+from ezmsg.util.generator import consumer, compose
 from ezmsg.util.messages.modify import modify_axis
-from ezmsg.sigproc.window import windowing
-from ezmsg.sigproc.spectrum import (
-    spectrum,
-    WindowFunction, SpectralTransform, SpectralOutput
-)
+
+from .window import windowing
+from .spectrum import spectrum, WindowFunction, SpectralTransform, SpectralOutput
+from .base import GenAxisArray
 
 
 @consumer
@@ -19,36 +16,53 @@ def spectrogram(
     window_shift: typing.Optional[float] = None,
     window: WindowFunction = WindowFunction.HANNING,
     transform: SpectralTransform = SpectralTransform.REL_DB,
-    output: SpectralOutput = SpectralOutput.POSITIVE
+    output: SpectralOutput = SpectralOutput.POSITIVE,
 ) -> typing.Generator[typing.Optional[AxisArray], AxisArray, None]:
+    """
+    Calculate a spectrogram on streaming data.
+
+    Chains :obj:`ezmsg.sigproc.window.windowing` to apply a moving window on the data,
+    :obj:`ezmsg.sigproc.spectrum.spectrum` to calculate spectra for each window,
+    and finally :obj:`ezmsg.util.messages.modify.modify_axis` to convert the win axis back to time axis.
+
+    Args:
+        window_dur: See :obj:`ezmsg.sigproc.window.windowing`
+        window_shift: See :obj:`ezmsg.sigproc.window.windowing`
+        window: See :obj:`ezmsg.sigproc.spectrum.spectrum`
+        transform: See :obj:`ezmsg.sigproc.spectrum.spectrum`
+        output: See :obj:`ezmsg.sigproc.spectrum.spectrum`
 
-    # We cannot use `compose` because `windowing` returns a list of axisarray objects,
-    #  even though the length is always exactly 1 for the settings used here.
-    # pipeline = compose(
-    f_win = windowing(axis="time", newaxis="step", window_dur=window_dur, window_shift=window_shift)
-    f_spec = spectrum(axis="time", window=window, transform=transform, output=output)
-    f_modify = modify_axis(name_map={"step": "time"})
-    # )
+    Returns:
+        A primed generator object that expects `.send(axis_array)` of continuous data
+        and yields an AxisArray of time-frequency power values.
+    """
+
+    pipeline = compose(
+        windowing(
+            axis="time", newaxis="win", window_dur=window_dur, window_shift=window_shift
+        ),
+        spectrum(axis="time", window=window, transform=transform, output=output),
+        modify_axis(name_map={"win": "time"}),
+    )
 
     # State variables
-    axis_arr_in = AxisArray(np.array([]), dims=[""])
-    axis_arr_out: typing.Optional[AxisArray] = None
+    msg_out: typing.Optional[AxisArray] = None
 
     while True:
-        axis_arr_in = yield axis_arr_out
-
-        # axis_arr_out = pipeline(axis_arr_in)
-        axis_arr_out = None
-        wins = f_win.send(axis_arr_in)
-        if len(wins):
-            specs = f_spec.send(wins[0])
-            if specs is not None:
-                axis_arr_out = f_modify.send(specs)
+        msg_in: AxisArray = yield msg_out
+        msg_out = pipeline(msg_in)
 
 
 class SpectrogramSettings(ez.Settings):
+    """
+    Settings for :obj:`Spectrogram`.
+    See :obj:`spectrogram` for a description of the parameters.
+    """
+
     window_dur: typing.Optional[float] = None  # window duration in seconds
-    window_shift: typing.Optional[float] = None  # window step in seconds. If None, window_shift == window_dur
+    window_shift: typing.Optional[float] = None
+    """"window step in seconds. If None, window_shift == window_dur"""
+
     # See SpectrumSettings for details of following settings:
     window: WindowFunction = WindowFunction.HAMMING
     transform: SpectralTransform = SpectralTransform.REL_DB
@@ -56,7 +70,11 @@ class SpectrogramSettings(ez.Settings):
 
 
 class Spectrogram(GenAxisArray):
-    SETTINGS: SpectrogramSettings
+    """
+    Unit for :obj:`spectrogram`.
+    """
+
+    SETTINGS = SpectrogramSettings
 
     def construct_generator(self):
         self.STATE.gen = spectrogram(
@@ -64,5 +82,5 @@ class Spectrogram(GenAxisArray):
             window_shift=self.SETTINGS.window_shift,
             window=self.SETTINGS.window,
             transform=self.SETTINGS.transform,
-            output=self.SETTINGS.output
+            output=self.SETTINGS.output,
         )

ezmsg/sigproc/spectrum.py

@@ -1,11 +1,14 @@
 from dataclasses import replace
 import enum
-from typing import Optional, Generator, AsyncGenerator
+from functools import partial
+import typing
 
 import numpy as np
 import ezmsg.core as ez
 from ezmsg.util.messages.axisarray import AxisArray, slice_along_axis
-from ezmsg.util.generator import consumer, GenAxisArray
+from ezmsg.util.generator import consumer
+
+from .base import GenAxisArray
 
 
 class OptionsEnum(enum.Enum):
@@ -15,11 +18,22 @@ class OptionsEnum(enum.Enum):
 
 
 class WindowFunction(OptionsEnum):
+    """Windowing function prior to calculating spectrum."""
+
     NONE = "None (Rectangular)"
+    """None."""
+
     HAMMING = "Hamming"
+    """:obj:`numpy.hamming`"""
+
     HANNING = "Hanning"
+    """:obj:`numpy.hanning`"""
+
     BARTLETT = "Bartlett"
+    """:obj:`numpy.bartlett`"""
+
     BLACKMAN = "Blackman"
+    """:obj:`numpy.blackman`"""
 
 
 WINDOWS = {
@@ -32,6 +46,8 @@ WINDOWS = {
 
 
 class SpectralTransform(OptionsEnum):
+    """Additional transformation functions to apply to the spectral result."""
+
     RAW_COMPLEX = "Complex FFT Output"
     REAL = "Real Component of FFT"
     IMAG = "Imaginary Component of FFT"
@@ -40,6 +56,8 @@ class SpectralTransform(OptionsEnum):
 
 
 class SpectralOutput(OptionsEnum):
+    """The expected spectral contents."""
+
     FULL = "Full Spectrum"
     POSITIVE = "Positive Frequencies"
     NEGATIVE = "Negative Frequencies"
@@ -47,112 +65,195 @@ class SpectralOutput(OptionsEnum):
 
 @consumer
 def spectrum(
-    axis: Optional[str] = None,
-    out_axis: Optional[str] = "freq",
+    axis: typing.Optional[str] = None,
+    out_axis: typing.Optional[str] = "freq",
     window: WindowFunction = WindowFunction.HANNING,
     transform: SpectralTransform = SpectralTransform.REL_DB,
-    output: SpectralOutput = SpectralOutput.POSITIVE
-) -> Generator[AxisArray, AxisArray, None]:
+    output: SpectralOutput = SpectralOutput.POSITIVE,
+    norm: typing.Optional[str] = "forward",
+    do_fftshift: bool = True,
+    nfft: typing.Optional[int] = None,
+) -> typing.Generator[AxisArray, AxisArray, None]:
+    """
+    Calculate a spectrum on a data slice.
+
+    Args:
+        axis: The name of the axis on which to calculate the spectrum.
+        out_axis: The name of the new axis. Defaults to "freq".
+        window: The :obj:`WindowFunction` to apply to the data slice prior to calculating the spectrum.
+        transform: The :obj:`SpectralTransform` to apply to the spectral magnitude.
+        output: The :obj:`SpectralOutput` format.
+        norm: Normalization mode. Default "forward" is best used when the inverse transform is not needed,
+          for example when the goal is to get spectral power. Use "backward" (equivalent to None) to not
+          scale the spectrum which is useful when the spectra will be manipulated and possibly inverse-transformed.
+          See numpy.fft.fft for details.
+        do_fftshift: Whether to apply fftshift to the output. Default is True. This value is ignored unless
+          output is SpectralOutput.FULL.
+        nfft: The number of points to use for the FFT. If None, the length of the input data is used.
+
+    Returns:
+        A primed generator object that expects `.send(axis_array)` of continuous data
+        and yields an AxisArray of spectral magnitudes or powers.
+    """
+    msg_out = AxisArray(np.array([]), dims=[""])
 
     # State variables
-    axis_arr_in = AxisArray(np.array([]), dims=[""])
-    axis_arr_out = AxisArray(np.array([]), dims=[""])
-
-    axis_name = axis
-    axis_idx = None
-    n_time = None
+    apply_window = window != WindowFunction.NONE
+    do_fftshift &= output == SpectralOutput.FULL
+    f_sl = slice(None)
+    freq_axis: typing.Optional[AxisArray.Axis] = None
+    fftfun: typing.Optional[typing.Callable] = None
+    f_transform: typing.Optional[typing.Callable] = None
+    new_dims: typing.Optional[typing.List[str]] = None
+
+    # Reset if input changes substantially
+    check_input = {
+        "n_time": None,  # Need to recalc windows
+        "ndim": None,  # Input ndim changed: Need to recalc windows
+        "kind": None,  # Input dtype changed: Need to re-init fft funcs
+        "ax_idx": None,  # Axis index changed: Need to re-init fft funcs
+        "gain": None,  # Gain changed: Need to re-calc freqs
+        # "key": None  # There's no temporal continuity; we can ignore key changes
+    }
 
     while True:
-        axis_arr_in = yield axis_arr_out
-
-        if axis_name is None:
-            axis_name = axis_arr_in.dims[0]
-
-        # Initial setup
-        if n_time is None or axis_idx is None or axis_arr_in.data.shape[axis_idx] != n_time:
-            axis_idx = axis_arr_in.get_axis_idx(axis_name)
-            _axis = axis_arr_in.get_axis(axis_name)
-            n_time = axis_arr_in.data.shape[axis_idx]
-            freqs = np.fft.fftshift(np.fft.fftfreq(n_time, d=_axis.gain), axes=-1)
-            window = WINDOWS[window](n_time)
-            window = window.reshape([1] * axis_idx + [len(window),] + [1] * (axis_arr_in.data.ndim-2))
-            if (transform != SpectralTransform.RAW_COMPLEX and
-                    not (transform == SpectralTransform.REAL or transform == SpectralTransform.IMAG)):
-                scale = np.sum(window ** 2.0) * _axis.gain
-            axis_offset = freqs[0]
-            if output == SpectralOutput.POSITIVE:
-                axis_offset = freqs[n_time // 2]
+        msg_in: AxisArray = yield msg_out
+
+        # Get signal properties
+        axis = axis or msg_in.dims[0]
+        ax_idx = msg_in.get_axis_idx(axis)
+        ax_info = msg_in.axes[axis]
+        targ_len = msg_in.data.shape[ax_idx]
+
+        # Check signal properties for change
+        b_reset = targ_len != check_input["n_time"]
+        b_reset = b_reset or msg_in.data.ndim != check_input["ndim"]
+        b_reset = b_reset or msg_in.data.dtype.kind != check_input["kind"]
+        b_reset = b_reset or ax_idx != check_input["ax_idx"]
+        b_reset = b_reset or ax_info.gain != check_input["gain"]
+        if b_reset:
+            check_input["n_time"] = targ_len
+            check_input["ndim"] = msg_in.data.ndim
+            check_input["kind"] = msg_in.data.dtype.kind
+            check_input["ax_idx"] = ax_idx
+            check_input["gain"] = ax_info.gain
+
+            nfft = nfft or targ_len
+
+            # Pre-calculate windowing
+            window = WINDOWS[window](targ_len)
+            window = window.reshape(
+                [1] * ax_idx
+                + [
+                    len(window),
+                ]
+                + [1] * (msg_in.data.ndim - 1 - ax_idx)
+            )
+            if transform != SpectralTransform.RAW_COMPLEX and not (
+                transform == SpectralTransform.REAL
+                or transform == SpectralTransform.IMAG
+            ):
+                scale = np.sum(window**2.0) * ax_info.gain
+
+            # Pre-calculate frequencies and select our fft function.
+            b_complex = msg_in.data.dtype.kind == "c"
+            if (not b_complex) and output == SpectralOutput.POSITIVE:
+                # If input is not complex and desired output is SpectralOutput.POSITIVE, we can save some computation
+                #  by using rfft and rfftfreq.
+                fftfun = partial(np.fft.rfft, n=nfft, axis=ax_idx, norm=norm)
+                freqs = np.fft.rfftfreq(nfft, d=ax_info.gain * targ_len / nfft)
+            else:
+                fftfun = partial(np.fft.fft, n=nfft, axis=ax_idx, norm=norm)
+                freqs = np.fft.fftfreq(nfft, d=ax_info.gain * targ_len / nfft)
+                if output == SpectralOutput.POSITIVE:
+                    f_sl = slice(None, nfft // 2 + 1 - (nfft % 2))
+                elif output == SpectralOutput.NEGATIVE:
+                    freqs = np.fft.fftshift(freqs, axes=-1)
+                    f_sl = slice(None, nfft // 2 + 1)
+                elif do_fftshift:  # and FULL
+                    freqs = np.fft.fftshift(freqs, axes=-1)
+                freqs = freqs[f_sl]
+            freqs = freqs.tolist()  # To please type checking
             freq_axis = AxisArray.Axis(
-                unit="Hz", gain=1.0 / (_axis.gain * n_time), offset=axis_offset
+                unit="Hz", gain=freqs[1] - freqs[0], offset=freqs[0]
             )
             if out_axis is None:
-                out_axis = axis_name
-            new_dims = axis_arr_in.dims[:axis_idx] + [out_axis, ] + axis_arr_in.dims[axis_idx + 1:]
+                out_axis = axis
+            new_dims = (
+                msg_in.dims[:ax_idx]
+                + [
+                    out_axis,
+                ]
+                + msg_in.dims[ax_idx + 1 :]
+            )
+
+            def f_transform(x):
+                return x
 
-            f_transform = lambda x: x
             if transform != SpectralTransform.RAW_COMPLEX:
                 if transform == SpectralTransform.REAL:
-                    f_transform = lambda x: x.real
+
+                    def f_transform(x):
+                        return x.real
                 elif transform == SpectralTransform.IMAG:
-                    f_transform = lambda x: x.imag
+
+                    def f_transform(x):
+                        return x.imag
                 else:
-                    f1 = lambda x: (2.0 * (np.abs(x) ** 2.0)) / scale
+
+                    def f1(x):
+                        return (np.abs(x) ** 2.0) / scale
+
                     if transform == SpectralTransform.REL_DB:
-                        f_transform = lambda x: 10 * np.log10(f1(x))
+
+                        def f_transform(x):
+                            return 10 * np.log10(f1(x))
                     else:
                         f_transform = f1
 
-        new_axes = {**axis_arr_in.axes, **{out_axis: freq_axis}}
-        if out_axis != axis_name:
-            new_axes.pop(axis_name, None)
-
-        spec = np.fft.fft(axis_arr_in.data * window, axis=axis_idx) / n_time
-        spec = np.fft.fftshift(spec, axes=axis_idx)
+        new_axes = {k: v for k, v in msg_in.axes.items() if k not in [out_axis, axis]}
+        new_axes[out_axis] = freq_axis
+
+        if apply_window:
+            win_dat = msg_in.data * window
+        else:
+            win_dat = msg_in.data
+        spec = fftfun(win_dat, n=nfft, axis=ax_idx, norm=norm)
+        # Note: norm="forward" equivalent to `/ nfft`
+        if do_fftshift or output == SpectralOutput.NEGATIVE:
+            spec = np.fft.fftshift(spec, axes=ax_idx)
         spec = f_transform(spec)
+        spec = slice_along_axis(spec, f_sl, ax_idx)
 
-        if output == SpectralOutput.POSITIVE:
-            spec = slice_along_axis(spec, slice(n_time // 2, None), axis_idx)
-
-        elif output == SpectralOutput.NEGATIVE:
-            spec = slice_along_axis(spec, slice(None, n_time // 2), axis_idx)
-
-        axis_arr_out = replace(axis_arr_in, data=spec, dims=new_dims, axes=new_axes)
+        msg_out = replace(msg_in, data=spec, dims=new_dims, axes=new_axes)
 
 
 class SpectrumSettings(ez.Settings):
-    axis: Optional[str] = None
-    # n: Optional[int] = None # n parameter for fft
-    out_axis: Optional[str] = "freq"  # If none; don't change dim name
+    """
+    Settings for :obj:`Spectrum.
+    See :obj:`spectrum` for a description of the parameters.
+    """
+
+    axis: typing.Optional[str] = None
+    # n: typing.Optional[int] = None # n parameter for fft
+    out_axis: typing.Optional[str] = "freq"  # If none; don't change dim name
     window: WindowFunction = WindowFunction.HAMMING
     transform: SpectralTransform = SpectralTransform.REL_DB
     output: SpectralOutput = SpectralOutput.POSITIVE
 
 
-class SpectrumState(ez.State):
-    gen: Generator
-    cur_settings: SpectrumSettings
-
-
 class Spectrum(GenAxisArray):
-    SETTINGS: SpectrumSettings
-    STATE: SpectrumState
+    """Unit for :obj:`spectrum`"""
 
-    INPUT_SETTINGS = ez.InputStream(SpectrumSettings)
-
-    def initialize(self) -> None:
-        self.STATE.cur_settings = self.SETTINGS
-        super().initialize()
+    SETTINGS = SpectrumSettings
 
-    @ez.subscriber(INPUT_SETTINGS)
-    async def on_settings(self, msg: SpectrumSettings):
-        self.STATE.cur_settings = msg
-        self.construct_generator()
+    INPUT_SETTINGS = ez.InputStream(SpectrumSettings)
 
     def construct_generator(self):
         self.STATE.gen = spectrum(
-            axis=self.STATE.cur_settings.axis,
-            out_axis=self.STATE.cur_settings.out_axis,
-            window=self.STATE.cur_settings.window,
-            transform=self.STATE.cur_settings.transform,
-            output=self.STATE.cur_settings.output
+            axis=self.SETTINGS.axis,
+            out_axis=self.SETTINGS.out_axis,
+            window=self.SETTINGS.window,
+            transform=self.SETTINGS.transform,
+            output=self.SETTINGS.output,
         )