ibl-neuropixel 1.9.1__tar.gz → 1.9.3__tar.gz

{ibl_neuropixel-1.9.1/src/ibl_neuropixel.egg-info → ibl_neuropixel-1.9.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ibl-neuropixel
-Version: 1.9.1
+Version: 1.9.3
 Summary: Collection of tools for Neuropixel 1.0 and 2.0 probes data
 Home-page: https://github.com/int-brain-lab/ibl-neuropixel
 Author: The International Brain Laboratory

{ibl_neuropixel-1.9.1 → ibl_neuropixel-1.9.3}/setup.py

@@ -8,7 +8,7 @@ with open("requirements.txt") as f:
 
 setuptools.setup(
     name="ibl-neuropixel",
-    version="1.9.1",
+    version="1.9.3",
     author="The International Brain Laboratory",
     description="Collection of tools for Neuropixel 1.0 and 2.0 probes data",
     long_description=long_description,

{ibl_neuropixel-1.9.1 → ibl_neuropixel-1.9.3/src/ibl_neuropixel.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ibl-neuropixel
-Version: 1.9.1
+Version: 1.9.3
 Summary: Collection of tools for Neuropixel 1.0 and 2.0 probes data
 Home-page: https://github.com/int-brain-lab/ibl-neuropixel
 Author: The International Brain Laboratory

{ibl_neuropixel-1.9.1 → ibl_neuropixel-1.9.3}/src/ibl_neuropixel.egg-info/SOURCES.txt

@@ -58,6 +58,7 @@ src/tests/integration/__init__.py
 src/tests/integration/csd_experiments.py
 src/tests/integration/test_destripe.py
 src/tests/unit/__init__.py
+src/tests/unit/test_cadzow.py
 src/tests/unit/test_ephys_np2.py
 src/tests/unit/test_neuropixel.py
 src/tests/unit/test_plots.py

{ibl_neuropixel-1.9.1 → ibl_neuropixel-1.9.3}/src/ibldsp/utils.py

@@ -383,21 +383,34 @@ class WindowGenerator(object):
             yield (first, last, amp)
 
     @property
-    def firstlast_valid(self, discard_edges=False):
+    def first_last_valid_noedge(self):
         """
         Generator that yields a tuple of first, last, first_valid, last_valid index of windows
-        The valid indices span up to half of the overlap
+        The valid indices span up to half of the overlap.
+        The first and last windows have respectively the beginning and end of the signal discarded.
         :return:
         """
+        return self._firstlast_valid(discard_edges=True)
+
+    @property
+    def firstlast_valid(self):
+        """
+        Generator that yields a tuple of first, last, first_valid, last_valid index of windows
+        The valid indices span up to half of the overlap.
+        The first and last windows have the full beginning and end of the signal respectively.
+        To discard the beginning and end edges, use firstlast_valid_noedge instead.
+        :return:
+        """
+        return self._firstlast_valid(self)
+
+    def _firstlast_valid(self, discard_edges=False):
         assert self.overlap % 2 == 0, "Overlap must be even"
         for first, last in self.firstlast:
             first_valid = (
-                0 if first == 0 and not discard_edges else first + self.overlap // 2
+                0 if first == 0 and discard_edges else first + self.overlap // 2
             )
             last_valid = (
-                last
-                if last == self.ns and not discard_edges
-                else last - self.overlap // 2
+                last if last == self.ns and discard_edges else last - self.overlap // 2
             )
             yield (first, last, first_valid, last_valid)
 

{ibl_neuropixel-1.9.1 → ibl_neuropixel-1.9.3}/src/ibldsp/voltage.py

@@ -790,21 +790,59 @@ def decompress_destripe_cbin(
 
 
 def detect_bad_channels(
-    raw, fs, similarity_threshold=(-0.5, 1), psd_hf_threshold=None, display=False
+    raw,
+    fs,
+    similarity_threshold=(-0.5, 1),
+    psd_hf_threshold=None,
+    display=False,
+    outside_threshold=-0.75,
 ):
     """
-    Bad channels detection for Neuropixel probes
-    Labels channels
-     0: all clear
-     1: dead low coherence / amplitude
-     2: noisy
-     3: outside of the brain
-    :param raw: [nc, ns]
-    :param fs: sampling frequency
-    :param similarity_threshold:
-    :param psd_hf_threshold:
-    :param display: optinal (False) will show a plot of features alongside a raw data snippet
-    :return: labels (numpy vector [nc]), xfeats: dictionary of features [nc]
+    Detect bad channels in Neuropixel probe recordings based on signal quality metrics.
+
+    This function analyzes raw electrophysiology data to identify and label problematic channels
+    using multiple criteria including cross-correlation with neighboring channels, power spectral
+    density analysis, and spatial coherence patterns. Channels are classified into four categories:
+    good (0), dead (1), noisy (2), or outside the brain (3).
+
+    Parameters
+    ----------
+    raw : numpy.ndarray
+        Raw voltage traces array with shape (nc, ns), where nc is the number of channels
+        and ns is the number of samples.
+    fs : float
+        Sampling frequency in Hz.
+    similarity_threshold : tuple of float, optional
+        Two-element tuple (lower, upper) defining the acceptable range for high-frequency
+        cross-correlation values. Channels outside this range are flagged as dead (below lower)
+        or noisy (above upper). Defaults to (-0.5, 1).
+    psd_hf_threshold : float, optional
+        Threshold for high-frequency power spectral density to identify noisy channels.
+        If None, defaults to 0.02 for AP band (fs > 2600 Hz) or 1.4 for LF band (fs <= 2600 Hz).
+        Units are µV²/Hz.
+    display : bool, optional
+        If True, displays a diagnostic plot showing channel features and a raw data snippet.
+        Defaults to False.
+    outside_threshold : float or str, optional
+        Threshold for low-frequency cross-correlation to identify channels outside the brain.
+        Can be a float value (default -0.75) or 'adaptive' for automatic threshold detection
+        based on signal gradient analysis.
+
+    Returns
+    -------
+    ichannels : numpy.ndarray
+        Integer array of shape (nc,) containing channel labels:
+        - 0: good channel
+        - 1: dead channel (low coherence/amplitude)
+        - 2: noisy channel (high noise or excessive correlation)
+        - 3: outside of the brain
+    xfeats : dict
+        Dictionary containing computed features for each channel:
+        - 'ind': channel indices
+        - 'rms_raw': RMS amplitude of raw signal
+        - 'xcor_hf': detrended high-frequency cross-correlation
+        - 'xcor_lf': low-frequency cross-correlation component
+        - 'psd_hf': mean power spectral density in high-frequency band
     """
 
     def rneighbours(raw, n=1):  # noqa
@@ -897,21 +935,28 @@ def detect_bad_channels(
     )[0]
     # the channels outside of the brains are the contiguous channels below the threshold on the trend coherency
 
-    signal_noisy = xfeats["xcor_lf"]
-    # Filter signal
-    window_size = 25  # Choose based on desired smoothing (e.g., 25 samples)
-    kernel = np.ones(window_size) / window_size
-    # Apply convolution
-    signal_filtered = np.convolve(signal_noisy, kernel, mode="same")
-
-    diff_x = np.diff(signal_filtered)
-    indx = np.where(diff_x < -0.02)[0]  # hardcoded threshold
-    if indx.size > 0:
-        indx_threshold = np.floor(np.median(indx)).astype(int)
-        threshold = signal_noisy[indx_threshold]
-        ioutside = np.where(signal_noisy < threshold)[0]
+    # deal with channels outside of the brain
+    if outside_threshold == "adaptive":
+        signal_noisy = xfeats["xcor_lf"]
+        # Filter signal
+        window_size = 25  # Choose based on desired smoothing (e.g., 25 samples)
+        kernel = np.ones(window_size) / window_size
+        # Apply convolution
+        signal_filtered = np.convolve(signal_noisy, kernel, mode="same")
+
+        diff_x = np.diff(signal_filtered)
+        indx = np.where(diff_x < -0.02)[0]  # hardcoded threshold
+        if indx.size > 0:
+            indx_threshold = np.floor(np.median(indx)).astype(int)
+            threshold = signal_noisy[indx_threshold]
+            ioutside = np.where(signal_noisy < threshold)[0]
+        else:
+            ioutside = np.array([])
     else:
-        ioutside = np.array([])
+        assert np.isreal(outside_threshold) and np.isscalar(outside_threshold), (
+            "outside_threshold must be a real number or 'adaptive' for adaptive threshold"
+        )
+        ioutside = np.where(xfeats["xcor_lf"] < outside_threshold)[0]
 
     if ioutside.size > 0 and ioutside[-1] == (nc - 1):
         a = np.cumsum(np.r_[0, np.diff(ioutside) - 1])

{ibl_neuropixel-1.9.1 → ibl_neuropixel-1.9.3}/src/ibldsp/waveforms.py

@@ -297,7 +297,7 @@ def plot_wiggle(
     return ax
 
 
-def double_wiggle(wav, fs=1, ax=None, colors=None, **kwargs):
+def double_wiggle(wav, fs=1, ax=None, colors=None, title=None, **kwargs):
     """
     Double trouble: this wiggle colours both the negative and the postive values
     :param wav: (nchannels, nsamples)
@@ -308,6 +308,7 @@ def double_wiggle(wav, fs=1, ax=None, colors=None, **kwargs):
     :param fill_sign: -1 for negative (default for spikes), 1 for positive
     :param plot_kwargs: kwargs for the line plot
     :param fill_kwargs: kwargs for the fill
+    :param title: title for the axis (optional)
     :return:
     """
     if colors is None:
@@ -334,6 +335,8 @@ def double_wiggle(wav, fs=1, ax=None, colors=None, **kwargs):
         fill_kwargs={"color": colors[1]},
         **kwargs,
     )
+    if title is not None:
+        ax.set(title=title)
     return ax
 
 

ibl_neuropixel-1.9.3/src/tests/unit/test_cadzow.py

@@ -0,0 +1,24 @@
+import unittest
+
+import numpy as np
+
+import ibldsp.cadzow
+import neuropixel
+
+
+class TestCadzow(unittest.TestCase):
+    def test_trajectory_matrixes_indices(self):
+        assert np.all(
+            ibldsp.cadzow.traj_matrix_indices(4) == np.array([[1, 0], [2, 1], [3, 2]])
+        )
+        assert np.all(
+            ibldsp.cadzow.traj_matrix_indices(3) == np.array([[1, 0], [2, 1]])
+        )
+
+    def test_trajectory(self):
+        th = neuropixel.trace_header(version=1)
+        tm, it, ic, trcount = ibldsp.cadzow.trajectory(
+            th["x"][:8], th["y"][:8], dtype=np.int32
+        )
+        # make sure tm can be indexed
+        np.testing.assert_array_equal(tm[it], 0)

{ibl_neuropixel-1.9.1 → ibl_neuropixel-1.9.3}/src/tests/unit/test_voltage.py

@@ -148,13 +148,3 @@ class TestSaturation(unittest.TestCase):
         saturation[45852:45865] = True
         df_sat = ibldsp.voltage.saturation_samples_to_intervals(saturation)
         self.assertEqual(81, np.sum(df_sat["stop_sample"] - df_sat["start_sample"]))
-
-
-class TestCadzow(unittest.TestCase):
-    def test_trajectory_matrixes(self):
-        assert np.all(
-            ibldsp.cadzow.traj_matrix_indices(4) == np.array([[1, 0], [2, 1], [3, 2]])
-        )
-        assert np.all(
-            ibldsp.cadzow.traj_matrix_indices(3) == np.array([[1, 0], [2, 1]])
-        )