ezmsg-sigproc 2.9.0__py3-none-any.whl → 2.11.0__py3-none-any.whl

ezmsg/sigproc/__version__.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '2.9.0'
-__version_tuple__ = version_tuple = (2, 9, 0)
+__version__ = version = '2.11.0'
+__version_tuple__ = version_tuple = (2, 11, 0)
 
 __commit_id__ = commit_id = None

ezmsg/sigproc/butterworthzerophase.py

@@ -1,42 +1,80 @@
+"""
+Streaming zero-phase Butterworth filter implemented as a two-stage composite processor.
+
+Stage 1: Forward causal Butterworth filter (from ezmsg.sigproc.butterworthfilter)
+Stage 2: Backward acausal filter with buffering (ButterworthBackwardFilterTransformer)
+
+The output is delayed by `pad_length` samples to ensure the backward pass has sufficient
+future context. The pad_length is computed analytically using scipy's heuristic.
+"""
+
 import functools
 import typing
 
-import ezmsg.core as ez
 import numpy as np
 import scipy.signal
-from ezmsg.baseproc import SettingsType
+from ezmsg.baseproc import BaseTransformerUnit
+from ezmsg.baseproc.composite import CompositeProcessor
 from ezmsg.util.messages.axisarray import AxisArray
 from ezmsg.util.messages.util import replace
 
-from ezmsg.sigproc.butterworthfilter import ButterworthFilterSettings, butter_design_fun
-from ezmsg.sigproc.filter import (
-    BACoeffs,
-    BaseFilterByDesignTransformerUnit,
-    FilterByDesignTransformer,
-    SOSCoeffs,
+from .butterworthfilter import (
+    ButterworthFilterSettings,
+    ButterworthFilterTransformer,
+    butter_design_fun,
 )
+from .filter import BACoeffs, FilterByDesignTransformer, SOSCoeffs
+from .util.axisarray_buffer import HybridAxisArrayBuffer
 
 
 class ButterworthZeroPhaseSettings(ButterworthFilterSettings):
-    """Settings for :obj:`ButterworthZeroPhase`."""
+    """
+    Settings for :obj:`ButterworthZeroPhase`.
+
+    This implements a streaming zero-phase Butterworth filter using forward-backward
+    filtering. The output is delayed by `pad_length` samples to ensure the backward
+    pass has sufficient future context.
+
+    The pad_length is computed by finding where the filter's impulse response decays
+    to `settle_cutoff` fraction of its peak value. This accounts for the filter's
+    actual time constant rather than just its order.
+    """
+
+    # Inherits from ButterworthFilterSettings:
+    # axis, coef_type, order, cuton, cutoff, wn_hz
 
-    # axis, coef_type, order, cuton, cutoff, wn_hz are inherited from ButterworthFilterSettings
-    padtype: str | None = None
+    settle_cutoff: float = 0.01
     """
-    Padding type to use in `scipy.signal.filtfilt`.
-    Must be one of {'odd', 'even', 'constant', None}.
-    Default is None for no padding.
+    Fraction of peak impulse response used to determine settling time.
+    The pad_length is set to the number of samples until the impulse response
+    decays to this fraction of its peak. Default is 0.01 (1% of peak).
     """
 
-    padlen: int | None = 0
+    max_pad_duration: float | None = None
     """
-    Length of the padding to use in `scipy.signal.filtfilt`.
-    If None, SciPy's default padding is used.
+    Maximum pad duration in seconds. If set, the pad_length will be capped
+    at this value times the sampling rate. Use this to limit latency for
+    filters with very long impulse responses. Default is None (no limit).
     """
 
 
-class ButterworthZeroPhaseTransformer(FilterByDesignTransformer[ButterworthZeroPhaseSettings, BACoeffs | SOSCoeffs]):
-    """Zero-phase (filtfilt) Butterworth using your design function."""
+class ButterworthBackwardFilterTransformer(FilterByDesignTransformer[ButterworthFilterSettings, BACoeffs | SOSCoeffs]):
+    """
+    Backward (acausal) Butterworth filter with buffering.
+
+    This transformer buffers its input and applies the filter in reverse,
+    outputting only the "settled" portion where transients have decayed.
+    This introduces a lag of ``pad_length`` samples.
+
+    Intended to be used as stage 2 in a zero-phase filter pipeline, receiving
+    forward-filtered data from a ButterworthFilterTransformer.
+    """
+
+    # Instance attributes (initialized in _reset_state)
+    _buffer: HybridAxisArrayBuffer | None
+    _coefs_cache: BACoeffs | SOSCoeffs | None
+    _zi_tiled: np.ndarray | None
+    _pad_length: int
 
     def get_design_function(
         self,
@@ -50,74 +88,218 @@ class ButterworthZeroPhaseTransformer(FilterByDesignTransformer[ButterworthZeroP
             wn_hz=self.settings.wn_hz,
         )
 
-    def update_settings(self, new_settings: typing.Optional[SettingsType] = None, **kwargs) -> None:
+    def _compute_pad_length(self, fs: float) -> int:
         """
-        Update settings and mark that filter coefficients need to be recalculated.
+        Compute pad length based on the filter's impulse response settling time.
+
+        The pad_length is determined by finding where the impulse response decays
+        to `settle_cutoff` fraction of its peak value. This is then optionally
+        capped by `max_pad_duration`.
 
         Args:
-            new_settings: Complete new settings object to replace current settings
-            **kwargs: Individual settings to update
+            fs: Sampling frequency in Hz.
+
+        Returns:
+            Number of samples for the pad length.
         """
-        # Update settings
-        if new_settings is not None:
-            self.settings = new_settings
+        # Design the filter to compute impulse response
+        coefs = self.get_design_function()(fs)
+        if coefs is None:
+            # Filter design failed or is disabled
+            return 0
+
+        # Generate impulse response - use a generous length initially
+        # Start with scipy's heuristic as minimum, then extend if needed
+        if self.settings.coef_type == "ba":
+            min_length = 3 * (self.settings.order + 1)
         else:
-            self.settings = replace(self.settings, **kwargs)
+            n_sections = (self.settings.order + 1) // 2
+            min_length = 3 * n_sections * 2
 
-        # Set flag to trigger recalculation on next message
-        self._coefs_cache = None
-        self._fs_cache = None
-        self.state.needs_redesign = True
+        # Use 10x the minimum as initial impulse length, or at least 10000 samples
+        # (10000 samples allows for ~333ms at 30kHz, covering most practical cases)
+        impulse_length = max(min_length * 10, 10000)
+
+        # Cap impulse length computation if max_pad_duration is set
+        if self.settings.max_pad_duration is not None:
+            max_samples = int(self.settings.max_pad_duration * fs)
+            impulse_length = min(impulse_length, max_samples + 1)
+
+        impulse = np.zeros(impulse_length)
+        impulse[0] = 1.0
+
+        if self.settings.coef_type == "ba":
+            b, a = coefs
+            h = scipy.signal.lfilter(b, a, impulse)
+        else:
+            h = scipy.signal.sosfilt(coefs, impulse)
+
+        # Find where impulse response settles to settle_cutoff of peak
+        abs_h = np.abs(h)
+        peak = abs_h.max()
+        if peak == 0:
+            return min_length
+
+        threshold = self.settings.settle_cutoff * peak
+        above_threshold = np.where(abs_h > threshold)[0]
+
+        if len(above_threshold) == 0:
+            pad_length = min_length
+        else:
+            pad_length = above_threshold[-1] + 1
+
+        # Ensure at least the scipy heuristic minimum
+        pad_length = max(pad_length, min_length)
+
+        # Apply max_pad_duration cap if set
+        if self.settings.max_pad_duration is not None:
+            max_samples = int(self.settings.max_pad_duration * fs)
+            pad_length = min(pad_length, max_samples)
+
+        return pad_length
 
     def _reset_state(self, message: AxisArray) -> None:
+        """Reset filter state when stream changes."""
         self._coefs_cache = None
-        self._fs_cache = None
+        self._zi_tiled = None
+        self._buffer = None
+        # Compute pad_length based on the message's sampling rate
+        axis = message.dims[0] if self.settings.axis is None else self.settings.axis
+        fs = 1 / message.axes[axis].gain
+        self._pad_length = self._compute_pad_length(fs)
         self.state.needs_redesign = True
 
+    def _compute_zi_tiled(self, data: np.ndarray, ax_idx: int) -> None:
+        """Compute and cache the tiled zi for the given data shape.
+
+        Called once per stream (or after filter redesign). The result is
+        broadcast-ready for multiplication by the edge sample on each chunk.
+        """
+        if self.settings.coef_type == "ba":
+            b, a = self._coefs_cache
+            zi_base = scipy.signal.lfilter_zi(b, a)
+        else:  # sos
+            zi_base = scipy.signal.sosfilt_zi(self._coefs_cache)
+
+        n_tail = data.ndim - ax_idx - 1
+
+        if self.settings.coef_type == "ba":
+            zi_expand = (None,) * ax_idx + (slice(None),) + (None,) * n_tail
+            n_tile = data.shape[:ax_idx] + (1,) + data.shape[ax_idx + 1 :]
+        else:  # sos
+            zi_expand = (slice(None),) + (None,) * ax_idx + (slice(None),) + (None,) * n_tail
+            n_tile = (1,) + data.shape[:ax_idx] + (1,) + data.shape[ax_idx + 1 :]
+
+        self._zi_tiled = np.tile(zi_base[zi_expand], n_tile)
+
+    def _initialize_zi(self, data: np.ndarray, ax_idx: int) -> np.ndarray:
+        """Initialize filter state (zi) scaled by edge value."""
+        if self._zi_tiled is None:
+            self._compute_zi_tiled(data, ax_idx)
+        first_sample = np.take(data, [0], axis=ax_idx)
+        return self._zi_tiled * first_sample
+
     def _process(self, message: AxisArray) -> AxisArray:
         axis = message.dims[0] if self.settings.axis is None else self.settings.axis
         ax_idx = message.get_axis_idx(axis)
         fs = 1 / message.axes[axis].gain
 
-        if (
-            self._coefs_cache is None
-            or self.state.needs_redesign
-            or (self._fs_cache is None or not np.isclose(self._fs_cache, fs))
-        ):
+        # Check if we need to redesign filter
+        if self._coefs_cache is None or self.state.needs_redesign:
             self._coefs_cache = self.get_design_function()(fs)
-            self._fs_cache = fs
+            self._pad_length = self._compute_pad_length(fs)
+            self._zi_tiled = None  # Invalidate; recomputed on next use.
             self.state.needs_redesign = False
 
+            # Initialize buffer with duration based on pad_length
+            # Add some margin to handle variable chunk sizes
+            buffer_duration = (self._pad_length + 1) / fs
+            self._buffer = HybridAxisArrayBuffer(duration=buffer_duration, axis=axis)
+
+        # Early exit if filter is effectively disabled
         if self._coefs_cache is None or self.settings.order <= 0 or message.data.size <= 0:
             return message
 
-        x = message.data
-        if self.settings.coef_type == "sos":
-            y = scipy.signal.sosfiltfilt(
-                self._coefs_cache,
-                x,
-                axis=ax_idx,
-                padtype=self.settings.padtype,
-                padlen=self.settings.padlen,
-            )
-        elif self.settings.coef_type == "ba":
+        # Write new data to buffer
+        self._buffer.write(message)
+        n_available = self._buffer.available()
+        n_output = n_available - self._pad_length
+
+        # If we don't have enough data yet, return empty
+        if n_output <= 0:
+            new_shape = list(message.data.shape)
+            new_shape[ax_idx] = 0
+            empty_data = np.empty(new_shape, dtype=message.data.dtype)
+            return replace(message, data=empty_data)
+
+        # Peek all available data from buffer
+        # Note: HybridAxisArrayBuffer moves the target axis to position 0
+        buffered = self._buffer.peek(n_available)
+        combined = buffered.data
+        buffer_ax_idx = 0  # Buffer always puts time axis at position 0
+
+        # Backward filter on reversed data
+        combined_rev = np.flip(combined, axis=buffer_ax_idx)
+        backward_zi = self._initialize_zi(combined_rev, buffer_ax_idx)
+
+        if self.settings.coef_type == "ba":
             b, a = self._coefs_cache
-            y = scipy.signal.filtfilt(
-                b,
-                a,
-                x,
-                axis=ax_idx,
-                padtype=self.settings.padtype,
-                padlen=self.settings.padlen,
-            )
-        else:
-            ez.logger.error("coef_type must be 'sos' or 'ba'.")
-            raise ValueError("coef_type must be 'sos' or 'ba'.")
+            y_bwd_rev, _ = scipy.signal.lfilter(b, a, combined_rev, axis=buffer_ax_idx, zi=backward_zi)
+        else:  # sos
+            y_bwd_rev, _ = scipy.signal.sosfilt(self._coefs_cache, combined_rev, axis=buffer_ax_idx, zi=backward_zi)
+
+        # Reverse back to get output in correct time order
+        y_bwd = np.flip(y_bwd_rev, axis=buffer_ax_idx)
+
+        # Output the settled portion (first n_output samples)
+        y = y_bwd[:n_output]
+
+        # Advance buffer read head to discard output samples, keep pad_length
+        self._buffer.seek(n_output)
+
+        # Build output with adjusted time axis
+        # LinearAxis offset is already correct from the buffer
+        out_axis = buffered.axes[axis]
+
+        # Move axis back to original position if needed
+        if ax_idx != 0:
+            y = np.moveaxis(y, 0, ax_idx)
+
+        return replace(
+            message,
+            data=y,
+            axes={**message.axes, axis: out_axis},
+        )
+
+
+class ButterworthZeroPhaseTransformer(CompositeProcessor[ButterworthZeroPhaseSettings, AxisArray, AxisArray]):
+    """
+    Streaming zero-phase Butterworth filter as a composite of two stages.
+
+    Stage 1 (forward): Standard causal Butterworth filter with state
+    Stage 2 (backward): Acausal Butterworth filter with buffering
+
+    The output is delayed by ``pad_length`` samples.
+    """
+
+    @staticmethod
+    def _initialize_processors(
+        settings: ButterworthZeroPhaseSettings,
+    ) -> dict[str, typing.Any]:
+        # Both stages use the same filter design settings
+        return {
+            "forward": ButterworthFilterTransformer(settings),
+            "backward": ButterworthBackwardFilterTransformer(settings),
+        }
 
-        return replace(message, data=y)
+    @classmethod
+    def get_message_type(cls, dir: str) -> type[AxisArray]:
+        if dir in ("in", "out"):
+            return AxisArray
+        raise ValueError(f"Invalid direction: {dir}. Must be 'in' or 'out'.")
 
 
 class ButterworthZeroPhase(
-    BaseFilterByDesignTransformerUnit[ButterworthZeroPhaseSettings, ButterworthZeroPhaseTransformer]
+    BaseTransformerUnit[ButterworthZeroPhaseSettings, AxisArray, AxisArray, ButterworthZeroPhaseTransformer]
 ):
     SETTINGS = ButterworthZeroPhaseSettings

ezmsg/sigproc/math/pow.py

@@ -0,0 +1,43 @@
+"""
+Element-wise power of the data.
+
+.. note::
+    This module supports the :doc:`Array API standard </guides/explanations/array_api>`,
+    enabling use with NumPy, CuPy, PyTorch, and other compatible array libraries.
+"""
+
+import ezmsg.core as ez
+from array_api_compat import get_namespace
+from ezmsg.baseproc import BaseTransformer, BaseTransformerUnit
+from ezmsg.util.messages.axisarray import AxisArray
+from ezmsg.util.messages.util import replace
+
+
+class PowSettings(ez.Settings):
+    exponent: float = 2.0
+    """The exponent to raise the data to. Default is 2.0 (squaring)."""
+
+
+class PowTransformer(BaseTransformer[PowSettings, AxisArray, AxisArray]):
+    def _process(self, message: AxisArray) -> AxisArray:
+        xp = get_namespace(message.data)
+        return replace(message, data=xp.pow(message.data, self.settings.exponent))
+
+
+class Pow(BaseTransformerUnit[PowSettings, AxisArray, AxisArray, PowTransformer]):
+    SETTINGS = PowSettings
+
+
+def pow(
+    exponent: float = 2.0,
+) -> PowTransformer:
+    """
+    Raise the data to an element-wise power. See :obj:`xp.pow` for more details.
+
+    Args:
+        exponent: The exponent to raise the data to. Default is 2.0.
+
+    Returns: :obj:`PowTransformer`.
+
+    """
+    return PowTransformer(PowSettings(exponent=exponent))

ezmsg/sigproc/scaler.py

@@ -7,7 +7,6 @@ from ezmsg.baseproc import (
     BaseTransformerUnit,
     processor_state,
 )
-from ezmsg.util.generator import consumer
 from ezmsg.util.messages.axisarray import AxisArray
 from ezmsg.util.messages.util import replace
 
@@ -18,50 +17,69 @@ from .ewma import _tau_from_alpha as _tau_from_alpha
 from .ewma import ewma_step as ewma_step
 
 
-@consumer
-def scaler(time_constant: float = 1.0, axis: str | None = None) -> typing.Generator[AxisArray, AxisArray, None]:
-    """
-    Apply the adaptive standard scaler from https://riverml.xyz/latest/api/preprocessing/AdaptiveStandardScaler/
-    This is faster than :obj:`scaler_np` for single-channel data.
+class RiverAdaptiveStandardScalerSettings(ez.Settings):
+    time_constant: float = 1.0
+    """Decay constant ``tau`` in seconds."""
+
+    axis: str | None = None
+    """The name of the axis to accumulate statistics over."""
+
+
+@processor_state
+class RiverAdaptiveStandardScalerState:
+    scaler: typing.Any = None
+    axis: str | None = None
+    axis_idx: int = 0
 
-    Args:
-        time_constant: Decay constant `tau` in seconds.
-        axis: The name of the axis to accumulate statistics over.
 
-    Returns:
-        A primed generator object that expects to be sent a :obj:`AxisArray` via `.send(axis_array)`
-         and yields an :obj:`AxisArray` with its data being a standardized, or "Z-scored" version of the input data.
+class RiverAdaptiveStandardScalerTransformer(
+    BaseStatefulTransformer[
+        RiverAdaptiveStandardScalerSettings,
+        AxisArray,
+        AxisArray,
+        RiverAdaptiveStandardScalerState,
+    ]
+):
+    """
+    Apply the adaptive standard scaler from
+    `river <https://riverml.xyz/latest/api/preprocessing/AdaptiveStandardScaler/>`_.
+
+    This processes data sample-by-sample using River's online learning
+    implementation. For a vectorized EWMA-based alternative, see
+    :class:`AdaptiveStandardScalerTransformer`.
     """
-    from river import preprocessing
 
-    msg_out = AxisArray(np.array([]), dims=[""])
-    _scaler = None
-    while True:
-        msg_in: AxisArray = yield msg_out
-        data = msg_in.data
+    def _reset_state(self, message: AxisArray) -> None:
+        from river import preprocessing
+
+        axis = self.settings.axis
         if axis is None:
-            axis = msg_in.dims[0]
-            axis_idx = 0
+            axis = message.dims[0]
+            self._state.axis_idx = 0
         else:
-            axis_idx = msg_in.get_axis_idx(axis)
-            if axis_idx != 0:
-                data = np.moveaxis(data, axis_idx, 0)
+            self._state.axis_idx = message.get_axis_idx(axis)
+        self._state.axis = axis
+
+        alpha = _alpha_from_tau(self.settings.time_constant, message.axes[axis].gain)
+        self._state.scaler = preprocessing.AdaptiveStandardScaler(fading_factor=alpha)
 
-        if _scaler is None:
-            alpha = _alpha_from_tau(time_constant, msg_in.axes[axis].gain)
-            _scaler = preprocessing.AdaptiveStandardScaler(fading_factor=alpha)
+    def _process(self, message: AxisArray) -> AxisArray:
+        data = message.data
+        axis_idx = self._state.axis_idx
+        if axis_idx != 0:
+            data = np.moveaxis(data, axis_idx, 0)
 
         result = []
         for sample in data:
             x = {k: v for k, v in enumerate(sample.flatten().tolist())}
-            _scaler.learn_one(x)
-            y = _scaler.transform_one(x)
+            self._state.scaler.learn_one(x)
+            y = self._state.scaler.transform_one(x)
             k = sorted(y.keys())
             result.append(np.array([y[_] for _ in k]).reshape(sample.shape))
 
         result = np.stack(result)
         result = np.moveaxis(result, 0, axis_idx)
-        msg_out = replace(msg_in, data=result)
+        return replace(message, data=result)
 
 
 class AdaptiveStandardScalerSettings(EWMASettings): ...
@@ -158,7 +176,14 @@ class AdaptiveStandardScaler(
             self.processor.settings = msg
 
 
-# Backwards compatibility...
+# Convenience functions to support deprecated generator API
+def scaler(time_constant: float = 1.0, axis: str | None = None) -> RiverAdaptiveStandardScalerTransformer:
+    """Create a :class:`RiverAdaptiveStandardScalerTransformer` with the given parameters."""
+    return RiverAdaptiveStandardScalerTransformer(
+        settings=RiverAdaptiveStandardScalerSettings(time_constant=time_constant, axis=axis)
+    )
+
+
 def scaler_np(time_constant: float = 1.0, axis: str | None = None) -> AdaptiveStandardScalerTransformer:
     return AdaptiveStandardScalerTransformer(
         settings=AdaptiveStandardScalerSettings(time_constant=time_constant, axis=axis)

ezmsg/sigproc/singlebandpow.py

@@ -0,0 +1,116 @@
+"""
+Time-domain single-band power estimation.
+
+Two methods are provided:
+
+1. **RMS Band Power** — Bandpass filter, square, window into bins, take the mean, optionally take the square root.
+2. **Square-Law + LPF Band Power** — Bandpass filter, square, lowpass filter (smoothing), downsample.
+"""
+
+from dataclasses import field
+
+import ezmsg.core as ez
+from ezmsg.baseproc import (
+    BaseProcessor,
+    BaseStatefulProcessor,
+    BaseTransformerUnit,
+    CompositeProcessor,
+)
+from ezmsg.util.messages.axisarray import AxisArray
+from ezmsg.util.messages.modify import modify_axis
+
+from .aggregate import AggregateSettings, AggregateTransformer, AggregationFunction
+from .butterworthfilter import ButterworthFilterSettings, ButterworthFilterTransformer
+from .downsample import DownsampleSettings, DownsampleTransformer
+from .math.pow import PowSettings, PowTransformer
+from .window import WindowTransformer
+
+
+class RMSBandPowerSettings(ez.Settings):
+    """Settings for :obj:`RMSBandPowerTransformer`."""
+
+    bandpass: ButterworthFilterSettings = field(
+        default_factory=lambda: ButterworthFilterSettings(order=4, coef_type="sos")
+    )
+    """Butterworth bandpass filter settings. Set ``cuton`` and ``cutoff`` to define the band."""
+
+    bin_duration: float = 0.05
+    """Duration of each non-overlapping bin in seconds."""
+
+    apply_sqrt: bool = True
+    """If True, output is RMS (root-mean-square). If False, output is mean-square power."""
+
+
+class RMSBandPowerTransformer(CompositeProcessor[RMSBandPowerSettings, AxisArray, AxisArray]):
+    """
+    RMS band power estimation.
+
+    Pipeline: bandpass -> square -> window(bins) -> mean(time) -> rename bin->time -> [sqrt]
+    """
+
+    @staticmethod
+    def _initialize_processors(
+        settings: RMSBandPowerSettings,
+    ) -> dict[str, BaseProcessor | BaseStatefulProcessor]:
+        procs: dict[str, BaseProcessor | BaseStatefulProcessor] = {
+            "bandpass": ButterworthFilterTransformer(settings.bandpass),
+            "square": PowTransformer(PowSettings(exponent=2.0)),
+            "window": WindowTransformer(
+                axis="time",
+                newaxis="bin",
+                window_dur=settings.bin_duration,
+                window_shift=settings.bin_duration,
+                zero_pad_until="none",
+            ),
+            "aggregate": AggregateTransformer(AggregateSettings(axis="time", operation=AggregationFunction.MEAN)),
+            "rename": modify_axis(name_map={"bin": "time"}),
+        }
+        if settings.apply_sqrt:
+            procs["sqrt"] = PowTransformer(PowSettings(exponent=0.5))
+        return procs
+
+
+class RMSBandPower(BaseTransformerUnit[RMSBandPowerSettings, AxisArray, AxisArray, RMSBandPowerTransformer]):
+    SETTINGS = RMSBandPowerSettings
+
+
+class SquareLawBandPowerSettings(ez.Settings):
+    """Settings for :obj:`SquareLawBandPowerTransformer`."""
+
+    bandpass: ButterworthFilterSettings = field(
+        default_factory=lambda: ButterworthFilterSettings(order=4, coef_type="sos")
+    )
+    """Butterworth bandpass filter settings. Set ``cuton`` and ``cutoff`` to define the band."""
+
+    lowpass: ButterworthFilterSettings = field(
+        default_factory=lambda: ButterworthFilterSettings(order=4, coef_type="sos")
+    )
+    """Butterworth lowpass filter settings for smoothing the squared signal."""
+
+    downsample: DownsampleSettings = field(default_factory=DownsampleSettings)
+    """Downsample settings for rate reduction after lowpass smoothing."""
+
+
+class SquareLawBandPowerTransformer(CompositeProcessor[SquareLawBandPowerSettings, AxisArray, AxisArray]):
+    """
+    Square-law + LPF band power estimation.
+
+    Pipeline: bandpass -> square -> lowpass -> downsample
+    """
+
+    @staticmethod
+    def _initialize_processors(
+        settings: SquareLawBandPowerSettings,
+    ) -> dict[str, BaseProcessor | BaseStatefulProcessor]:
+        return {
+            "bandpass": ButterworthFilterTransformer(settings.bandpass),
+            "square": PowTransformer(PowSettings(exponent=2.0)),
+            "lowpass": ButterworthFilterTransformer(settings.lowpass),
+            "downsample": DownsampleTransformer(settings.downsample),
+        }
+
+
+class SquareLawBandPower(
+    BaseTransformerUnit[SquareLawBandPowerSettings, AxisArray, AxisArray, SquareLawBandPowerTransformer]
+):
+    SETTINGS = SquareLawBandPowerSettings

{ezmsg_sigproc-2.9.0.dist-info → ezmsg_sigproc-2.11.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ezmsg-sigproc
-Version: 2.9.0
+Version: 2.11.0
 Summary: Timeseries signal processing implementations in ezmsg
 Author-email: Griffin Milsap <griffin.milsap@gmail.com>, Preston Peranich <pperanich@gmail.com>, Chadwick Boulay <chadwick.boulay@gmail.com>, Kyle McGraw <kmcgraw@blackrockneuro.com>
 License-Expression: MIT

{ezmsg_sigproc-2.9.0.dist-info → ezmsg_sigproc-2.11.0.dist-info}/RECORD

@@ -1,5 +1,5 @@
 ezmsg/sigproc/__init__.py,sha256=8K4IcOA3-pfzadoM6s2Sfg5460KlJUocGgyTJTJl96U,52
-ezmsg/sigproc/__version__.py,sha256=24D27WSWcO2HaMUGCrVCG6Zbd76BrLDh2qQ1KbGX6Hc,704
+ezmsg/sigproc/__version__.py,sha256=eqKbWb9LnxuZWE9-pafopBz45ugg0beSlKLIOIjeSzc,706
 ezmsg/sigproc/activation.py,sha256=83vnTa3ZcC4Q3VSWcGfaqhCEqYRNySUOyVpMHZXfz-c,2755
 ezmsg/sigproc/adaptive_lattice_notch.py,sha256=ThUR48mbSHuThkimtD0j4IXNMrOVcpZgGhE7PCYfXhU,8818
 ezmsg/sigproc/affinetransform.py,sha256=jl7DiSa5Yb0qsmFJbfSiSeGmvK1SGoBgycFC5JU5DVY,9434
@@ -7,7 +7,7 @@ ezmsg/sigproc/aggregate.py,sha256=7Hdz1m-S6Cl9h0oRQHeS_UTGBemhOB4XdFyX6cGcdHo,93
 ezmsg/sigproc/bandpower.py,sha256=dAhH56sUrXNhcRFymTTwjdM_KcU5OxFzrR_sxIPAxyw,2264
 ezmsg/sigproc/base.py,sha256=SJvKEb8gw6mUMwlV5sH0iPG0bXrgS8tvkPwhI-j89MQ,3672
 ezmsg/sigproc/butterworthfilter.py,sha256=NKTGkgjvlmC1Dc9gD2Z6UBzUq12KicfnczrzM5ZTosk,5255
-ezmsg/sigproc/butterworthzerophase.py,sha256=Df3F1QBBE39FBjNi67wvTsb1bSdTRTSTZXbZiKFlxC4,4105
+ezmsg/sigproc/butterworthzerophase.py,sha256=CU6cXkI6j1LQCEz0sr2IthAPCq_TEtbvSb7h2Nw1w74,11820
 ezmsg/sigproc/cheby.py,sha256=B8pGt5_pOBpNZCmaibNl_NKkyuasd8ZEJXeTDCTaino,3711
 ezmsg/sigproc/combfilter.py,sha256=MSxr1I-jBePW_9AuCiv3RQ1HUNxIsNhLk0q1Iu8ikAw,4766
 ezmsg/sigproc/coordinatespaces.py,sha256=bp_0fTS9b27OQqLoFzgE3f9rb287P8y0S1dWWGrS08o,5298
@@ -34,8 +34,9 @@ ezmsg/sigproc/quantize.py,sha256=uSM2z2xXwL0dgSltyzLEmlKjaJZ2meA3PDWX8_bM0Hs,219
 ezmsg/sigproc/resample.py,sha256=3mm9pvxryNVhQuTCIMW3ToUkUfbVOCsIgvXUiurit1Y,11389
 ezmsg/sigproc/rollingscaler.py,sha256=e-smSKDhmDD2nWIf6I77CtRxQp_7sHS268SGPi7aXp8,8499
 ezmsg/sigproc/sampler.py,sha256=iOk2YoUX22u9iTjFKimzP5V074RDBVcmswgfyxvZRZo,10761
-ezmsg/sigproc/scaler.py,sha256=oBZa6uzyftChvk6aqBD5clil6pedx3IF-dptrb74EA0,5888
+ezmsg/sigproc/scaler.py,sha256=nCgShZufPId_b-Sbsc8Si31lbtOb3nPImNcnksd774w,6578
 ezmsg/sigproc/signalinjector.py,sha256=mB62H2b-ScgPtH1jajEpxgDHqdb-RKekQfgyNncsE8Y,2874
+ezmsg/sigproc/singlebandpow.py,sha256=BVlWhFI6zU3ME3EVdZbwf-FMz1d2sfuNFDKXs1hn5HM,4353
 ezmsg/sigproc/slicer.py,sha256=xLXxWf722V08ytVwvPimYjDKKj0pkC2HjdgCVaoaOvs,5195
 ezmsg/sigproc/spectral.py,sha256=wFzuihS7qJZMQcp0ds_qCG-zCbvh5DyhFRjn2wA9TWQ,322
 ezmsg/sigproc/spectrogram.py,sha256=g8xYWENzle6O5uEF-vfjsF5gOSDnJTwiu3ZudicO470,2893
@@ -50,6 +51,7 @@ ezmsg/sigproc/math/clip.py,sha256=1D6mUlOzBB7L35G_KKYZmfg7nYlbuDdITV4EH0R-yUo,15
 ezmsg/sigproc/math/difference.py,sha256=uUYZgbLe-GrFSN6EOFjs9fQZllp827IluxL6m8TJuH8,4791
 ezmsg/sigproc/math/invert.py,sha256=nz8jbfvDoez6s9NmAprBtTAI5oSDj0wNUPk8j13XiVk,855
 ezmsg/sigproc/math/log.py,sha256=JhjSqLnQnvx_3F4txRYHuUPSJ12Yj2HvRTsCMNvlxpo,2022
+ezmsg/sigproc/math/pow.py,sha256=0sdlXFUEBXmpEV_i75oshGRjMguv8L13nLt7hlvdX3E,1284
 ezmsg/sigproc/math/scale.py,sha256=4_xHcHNuf13E1fxIF5vbkPfkN4En6zkfPIKID7lCERk,1133
 ezmsg/sigproc/util/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 ezmsg/sigproc/util/asio.py,sha256=aAj0e7OoBvkRy28k05HL2s9YPCTxOddc05xMN-qd4lQ,577
@@ -59,7 +61,7 @@ ezmsg/sigproc/util/message.py,sha256=ppN3IYtIAwrxWG9JOvgWFn1wDdIumkEzYFfqpH9VQkY
 ezmsg/sigproc/util/profile.py,sha256=eVOo9pXgusrnH1yfRdd2RsM7Dbe2UpyC0LJ9MfGpB08,416
 ezmsg/sigproc/util/sparse.py,sha256=NjbJitCtO0B6CENTlyd9c-lHEJwoCan-T3DIgPyeShw,4834
 ezmsg/sigproc/util/typeresolution.py,sha256=fMFzLi63dqCIclGFLcMdM870OYxJnkeWw6aWKNMk718,362
-ezmsg_sigproc-2.9.0.dist-info/METADATA,sha256=H7aJdYvhCekfdihzdsPbvT1a942faGRIlcoeDd_23HI,1908
-ezmsg_sigproc-2.9.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-ezmsg_sigproc-2.9.0.dist-info/licenses/LICENSE,sha256=seu0tKhhAMPCUgc1XpXGGaCxY1YaYvFJwqFuQZAl2go,1100
-ezmsg_sigproc-2.9.0.dist-info/RECORD,,
+ezmsg_sigproc-2.11.0.dist-info/METADATA,sha256=8XB8fu3sNqsrwV-ff8xtlWUKsFdERMSqqkotMhfNtu0,1909
+ezmsg_sigproc-2.11.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+ezmsg_sigproc-2.11.0.dist-info/licenses/LICENSE,sha256=seu0tKhhAMPCUgc1XpXGGaCxY1YaYvFJwqFuQZAl2go,1100
+ezmsg_sigproc-2.11.0.dist-info/RECORD,,