ezmsg-sigproc 1.6.0__tar.gz → 1.7.0__tar.gz

{ezmsg_sigproc-1.6.0 → ezmsg_sigproc-1.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: ezmsg-sigproc
-Version: 1.6.0
+Version: 1.7.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>
 License: MIT

{ezmsg_sigproc-1.6.0 → ezmsg_sigproc-1.7.0}/src/ezmsg/sigproc/__version__.py

@@ -12,5 +12,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '1.6.0'
-__version_tuple__ = version_tuple = (1, 6, 0)
+__version__ = version = '1.7.0'
+__version_tuple__ = version_tuple = (1, 7, 0)

{ezmsg_sigproc-1.6.0 → ezmsg_sigproc-1.7.0}/src/ezmsg/sigproc/decimate.py

@@ -1,8 +1,31 @@
+import typing
+
 import ezmsg.core as ez
 from ezmsg.util.messages.axisarray import AxisArray
 
 from .cheby import ChebyshevFilter, ChebyshevFilterSettings
 from .downsample import Downsample, DownsampleSettings
+from .filter import FilterCoefsMultiType
+
+
+class ChebyForDecimate(ChebyshevFilter):
+    """
+    A :obj:`ChebyshevFilter` node with a design filter method that additionally accepts a target sampling rate,
+     and if the target rate cannot be achieved it returns None, else it returns the filter coefficients.
+    """
+
+    def design_filter(
+        self,
+    ) -> typing.Callable[[float], FilterCoefsMultiType | None]:
+        def cheby_opt_design_fun(fs: float) -> FilterCoefsMultiType | None:
+            if fs is None:
+                return None
+            ds_factor = int(fs / (2.5 * self.SETTINGS.Wn))
+            if ds_factor < 2:
+                return None
+            partial_fun = super(ChebyForDecimate, self).design_filter()
+            return partial_fun(fs)
+        return cheby_opt_design_fun
 
 
 class Decimate(ez.Collection):
@@ -16,17 +39,18 @@ class Decimate(ez.Collection):
     INPUT_SIGNAL = ez.InputStream(AxisArray)
     OUTPUT_SIGNAL = ez.OutputStream(AxisArray)
 
-    FILTER = ChebyshevFilter()
+    FILTER = ChebyForDecimate()
     DOWNSAMPLE = Downsample()
 
     def configure(self) -> None:
+
         cheby_settings = ChebyshevFilterSettings(
-            order=8 if self.SETTINGS.factor > 1 else 0,
+            order=8,
             ripple_tol=0.05,
-            Wn=0.8 / self.SETTINGS.factor if self.SETTINGS.factor > 1 else None,
+            Wn=0.4 * self.SETTINGS.target_rate,
             btype="lowpass",
             axis=self.SETTINGS.axis,
-            wn_hz=False,
+            wn_hz=True,
         )
         self.FILTER.apply_settings(cheby_settings)
         self.DOWNSAMPLE.apply_settings(self.SETTINGS)

{ezmsg_sigproc-1.6.0 → ezmsg_sigproc-1.7.0}/src/ezmsg/sigproc/downsample.py

@@ -14,7 +14,7 @@ from .base import GenAxisArray
 
 @consumer
 def downsample(
-    axis: str | None = None, factor: int = 1
+    axis: str | None = None, target_rate: float | None = None
 ) -> typing.Generator[AxisArray, AxisArray, None]:
     """
     Construct a generator that yields a downsampled version of the data .send() to it.
@@ -26,7 +26,8 @@ def downsample(
     Args:
         axis: The name of the axis along which to downsample.
             Note: The axis must exist in the message .axes and be of type AxisArray.LinearAxis.
-        factor: Downsampling factor.
+        target_rate: Desired rate after downsampling. The actual rate will be the nearest integer factor of the
+            input rate that is the same or higher than the target rate.
 
     Returns:
         A primed generator object ready to receive an :obj:`AxisArray` via `.send(axis_array)`
@@ -37,10 +38,8 @@ def downsample(
     """
     msg_out = AxisArray(np.array([]), dims=[""])
 
-    if factor < 1:
-        raise ValueError("Downsample factor must be at least 1 (no downsampling)")
-
     # state variables
+    factor: int = 0  # The integer downsampling factor. It will be determined based on the target rate.
     s_idx: int = 0  # Index of the next msg's first sample into the virtual rotating ds_factor counter.
 
     check_input = {"gain": None, "key": None}
@@ -62,6 +61,16 @@ def downsample(
             check_input["key"] = msg_in.key
             # Reset state variables
             s_idx = 0
+            if target_rate is None:
+                factor = 1
+            else:
+                factor = int(1 / (axis_info.gain * target_rate))
+            if factor < 1:
+                ez.logger.warning(
+                    f"Target rate {target_rate} cannot be achieved with input rate of {1/axis_info.gain}."
+                    "Setting factor to 1."
+                )
+                factor = 1
 
         n_samples = msg_in.data.shape[axis_idx]
         samples = np.arange(s_idx, s_idx + n_samples) % factor
@@ -97,7 +106,7 @@ class DownsampleSettings(ez.Settings):
     """
 
     axis: str | None = None
-    factor: int = 1
+    target_rate: float | None = None
 
 
 class Downsample(GenAxisArray):
@@ -107,5 +116,5 @@ class Downsample(GenAxisArray):
 
     def construct_generator(self):
         self.STATE.gen = downsample(
-            axis=self.SETTINGS.axis, factor=self.SETTINGS.factor
+            axis=self.SETTINGS.axis, target_rate=self.SETTINGS.target_rate
         )

{ezmsg_sigproc-1.6.0 → ezmsg_sigproc-1.7.0}/tests/test_decimate.py

@@ -13,8 +13,8 @@ from ezmsg.sigproc.synth import EEGSynth
 from util import get_test_fn
 
 
-@pytest.mark.parametrize("factor", [5.0, 1.0])
-def test_decimate_system(factor: float):
+@pytest.mark.parametrize("target_rate", [100.0, 500.0])
+def test_decimate_system(target_rate: float):
     test_filename = get_test_fn()
     test_filename_raw = test_filename.parent / (
         test_filename.stem + "raw" + test_filename.suffix
@@ -27,7 +27,7 @@ def test_decimate_system(factor: float):
 
     comps = {
         "SRC": EEGSynth(n_time=n_time, fs=fs, n_ch=n_ch, alpha_freq=10.5),
-        "DECIMATE": Decimate(axis="time", factor=factor),
+        "DECIMATE": Decimate(axis="time", target_rate=target_rate),
         "LOGRAW": MessageLogger(output=test_filename_raw),
         "LOGFILT": MessageLogger(output=test_filename),
         "TERM": TerminateOnTotal(n_total),
@@ -47,13 +47,14 @@ def test_decimate_system(factor: float):
     inputs = AxisArray.concatenate(*inputs, dim="time")
     outputs = AxisArray.concatenate(*messages, dim="time")
 
-    if factor == 1:
+    expected_factor: int = int(fs // target_rate)
+    if expected_factor == 1:
         expected = inputs.data
     else:
-        b, a = scipy.signal.cheby1(8, 0.05, 0.8 / factor)
+        b, a = scipy.signal.cheby1(8, 0.05, 0.8 / expected_factor)
         b, a = scipy.signal.normalize(b, a)
         zi = scipy.signal.lfilter_zi(b, a)[:, None]
         antialiased, _ = scipy.signal.lfilter(b, a, inputs.data, axis=0, zi=zi)
-        expected = antialiased[:: int(factor)]
+        expected = antialiased[:: int(expected_factor)]
 
     assert np.allclose(outputs.data, expected)

{ezmsg_sigproc-1.6.0 → ezmsg_sigproc-1.7.0}/tests/test_downsample.py

@@ -20,8 +20,8 @@ from ezmsg.util.debuglog import DebugLog
 
 
 @pytest.mark.parametrize("block_size", [1, 5, 10, 20])
-@pytest.mark.parametrize("factor", [1, 2, 3])
-def test_downsample_core(block_size: int, factor: int):
+@pytest.mark.parametrize("target_rate", [19.0, 9.5, 6.3])
+def test_downsample_core(block_size: int, target_rate: float):
     in_fs = 19.0
     test_dur = 4.0
     n_channels = 2
@@ -60,7 +60,7 @@ def test_downsample_core(block_size: int, factor: int):
     in_msgs = list(msg_generator())
     backup = [copy.deepcopy(msg) for msg in in_msgs]
 
-    proc = downsample(axis="time", factor=factor)
+    proc = downsample(axis="time", target_rate=target_rate)
     out_msgs = []
     for msg in in_msgs:
         res = proc.send(msg)
@@ -70,18 +70,19 @@ def test_downsample_core(block_size: int, factor: int):
     assert_messages_equal(in_msgs, backup)
 
     # Assert correctness of gain
-    assert all(msg.axes["time"].gain == factor / in_fs for msg in out_msgs)
+    expected_factor: int = int(in_fs // target_rate)
+    assert all(msg.axes["time"].gain == expected_factor / in_fs for msg in out_msgs)
 
     # Assert messages have the correct timestamps
     expected_offsets = (
-        np.cumsum([0] + [_.data.shape[0] for _ in out_msgs]) * factor / in_fs
+        np.cumsum([0] + [_.data.shape[0] for _ in out_msgs]) * expected_factor / in_fs
     )
     actual_offsets = np.array([_.axes["time"].offset for _ in out_msgs])
     assert np.allclose(actual_offsets, expected_offsets[:-1])
 
     # Compare returned values to expected values.
     allres_msg = AxisArray.concatenate(*out_msgs, dim="time")
-    assert np.array_equal(allres_msg.data, sig[::factor])
+    assert np.array_equal(allres_msg.data, sig[::expected_factor])
 
 
 class DownsampleSystemSettings(ez.Settings):
@@ -130,8 +131,8 @@ class DownsampleSystem(ez.Collection):
 
 
 @pytest.mark.parametrize("block_size", [10])
-@pytest.mark.parametrize("factor", [3])
-def test_downsample_system(block_size: int, factor: int, test_name: str | None = None):
+@pytest.mark.parametrize("target_rate", [6.3])
+def test_downsample_system(block_size: int, target_rate: float, test_name: str | None = None):
     in_fs = 19.0
     num_msgs = int(4.0 / (block_size / in_fs))  # Ensure 4 seconds of data
 
@@ -145,7 +146,7 @@ def test_downsample_system(block_size: int, factor: int, test_name: str | None =
             fs=in_fs,
             dispatch_rate=20.0,
         ),
-        down_settings=DownsampleSettings(factor=factor),
+        down_settings=DownsampleSettings(target_rate=target_rate),
         log_settings=MessageLoggerSettings(output=test_filename),
         term_settings=TerminateTestSettings(time=1.0),
     )
@@ -159,7 +160,8 @@ def test_downsample_system(block_size: int, factor: int, test_name: str | None =
     ez.logger.info(f"Analyzing recording of { len( messages ) } messages...")
 
     # Check fs
-    out_fs = in_fs / factor
+    expected_factor: int = int(in_fs // target_rate)
+    out_fs = in_fs / expected_factor
     assert np.allclose(
         np.array([1 / msg.axes["time"].gain for msg in messages]),
         np.ones(
@@ -173,7 +175,7 @@ def test_downsample_system(block_size: int, factor: int, test_name: str | None =
     # Check data
     time_ax_idx = messages[0].get_axis_idx("time")
     data = np.concatenate([_.data for _ in messages], axis=time_ax_idx)
-    expected_data = np.arange(data.shape[time_ax_idx]) * factor
+    expected_data = np.arange(data.shape[time_ax_idx]) * expected_factor
     assert np.array_equal(data, expected_data[:, None])
 
     # Grab first sample from each message. We will use their values to get the offsets.
@@ -185,7 +187,7 @@ def test_downsample_system(block_size: int, factor: int, test_name: str | None =
 
     # Check offsets
     first_samps = np.concatenate(first_samps, axis=time_ax_idx)
-    expected_offsets = first_samps.squeeze() / out_fs / factor
+    expected_offsets = first_samps.squeeze() / out_fs / expected_factor
     assert np.allclose(
         np.array([msg.axes["time"].offset for msg in messages]), expected_offsets
     )

{ezmsg_sigproc-1.6.0 → ezmsg_sigproc-1.7.0}/uv.lock

@@ -115,7 +115,7 @@ wheels = [
 
 [[package]]
 name = "ezmsg-sigproc"
-version = "1.4.3.dev34+gbfb0671.d20241122"
+version = "1.6.0"
 source = { editable = "." }
 dependencies = [
     { name = "ezmsg" },