Fix gaussian filter with time vector (#4268)

Co-authored-by: Chris Halcrow <57948917+chrishalcrow@users.noreply.github.com>

Author: alejoe91

src/spikeinterface/core/zarrextractors.py

@@ -161,7 +161,7 @@ def __init__(
                     if np.isnan(t_start):
                         t_start = None
                 time_kwargs["t_start"] = t_start
-                time_kwargs["sampling_frequency"] = sampling_frequency
+            time_kwargs["sampling_frequency"] = sampling_frequency
 
             rec_segment = ZarrRecordingSegment(self._root, trace_name, **time_kwargs)
             self.add_recording_segment(rec_segment)

src/spikeinterface/preprocessing/filter_gaussian.py

@@ -50,29 +50,37 @@ def __init__(
             raise ValueError("At least one of `freq_min`,`freq_max` should be specified.")
 
         for parent_segment in recording._recording_segments:
-            self.add_recording_segment(GaussianFilterRecordingSegment(parent_segment, freq_min, freq_max, margin_sd))
+            # Sampling frequency is taken from recording since segments may not have it set (in case of time_vector)
+            self.add_recording_segment(
+                GaussianFilterRecordingSegment(parent_segment, freq_min, freq_max, margin_sd, self.sampling_frequency)
+            )
 
         self._kwargs = {"recording": recording, "freq_min": freq_min, "freq_max": freq_max}
 
 
 class GaussianFilterRecordingSegment(BasePreprocessorSegment):
     def __init__(
-        self, parent_recording_segment: BaseRecordingSegment, freq_min: float, freq_max: float, margin_sd: float = 5.0
+        self,
+        parent_recording_segment: BaseRecordingSegment,
+        freq_min: float,
+        freq_max: float,
+        margin_sd: float = 5.0,
+        parent_sampling_frequency: float = None,
     ):
         BasePreprocessorSegment.__init__(self, parent_recording_segment)
 
         self.freq_min = freq_min
         self.freq_max = freq_max
         self.cached_gaussian = dict()
 
-        sf = parent_recording_segment.sampling_frequency
+        self.parent_sampling_frequency = parent_sampling_frequency
 
         # Margin from widest gaussian
         sigmas = []
         if freq_min is not None:
-            sigmas.append(sf / (2 * np.pi * freq_min))
+            sigmas.append(self.parent_sampling_frequency / (2 * np.pi * freq_min))
         if freq_max is not None:
-            sigmas.append(sf / (2 * np.pi * freq_max))
+            sigmas.append(self.parent_sampling_frequency / (2 * np.pi * freq_max))
         self.margin = 1 + int(max(sigmas) * margin_sd)
 
     def get_traces(
@@ -117,11 +125,12 @@ def _create_gaussian(self, N: int, cutoff_f: float):
         if cutoff_f in self.cached_gaussian and N in self.cached_gaussian[cutoff_f]:
             return self.cached_gaussian[cutoff_f][N]
 
-        sf = self.parent_recording_segment.sampling_frequency
-        faxis = np.fft.fftfreq(N, d=1 / sf)
+        faxis = np.fft.fftfreq(N, d=1 / self.parent_sampling_frequency)
 
-        if cutoff_f > sf / 8:  # The Fourier transform of a Gaussian with a very low sigma isn't a Gaussian.
-            sigma = sf / (2 * np.pi * cutoff_f)
+        if (
+            cutoff_f > self.parent_sampling_frequency / 8
+        ):  # The Fourier transform of a Gaussian with a very low sigma isn't a Gaussian.
+            sigma = self.parent_sampling_frequency / (2 * np.pi * cutoff_f)
             limit = int(round(5 * sigma)) + 1
             xaxis = np.arange(-limit, limit + 1) / sigma
             gaussian = normal_pdf(xaxis) / sigma

src/spikeinterface/preprocessing/tests/test_filter_gaussian.py

@@ -36,6 +36,14 @@ def test_filter_gaussian(tmp_path):
         assert np.allclose(original_trace[60:-60], saved1_trace[60:-60], rtol=1e-3, atol=1e-3)
         assert np.allclose(original_trace[60:-60], saved2_trace[60:-60], rtol=1e-3, atol=1e-3)
 
+    # test filter gaussian with time_Vector
+    for segment_index in range(recording.get_num_segments()):
+        times = recording.get_times(segment_index) + (segment_index + 1) * 10.0
+        recording.set_times(times, segment_index=segment_index)
+
+    rec_filtered_tv = gaussian_filter(recording)
+    assert rec_filtered_tv.get_traces(segment_index=0, end_frame=100).shape == (100, 3)
+
 
 @pytest.mark.parametrize("freq_min", [None, 10, 50, 100])
 @pytest.mark.parametrize("freq_max", [None, 10, 50, 100])