_clock_sync: Handle LinAlgError and empty clock offset regions

* time-stamps within an unusable clock offset region (LinAlgError) are
  not synchronized but the clock_segment is retained

* empty clock offset regions are discarded because they do not map to
  any time-stamp indices

Author: jamieforth

src/pyxdf/pyxdf.py

@@ -676,11 +676,19 @@ def _clock_sync(
                         ]
                     )
                     y = np.array(clock_values[start:stop]) / winsor_threshold
-                    # noinspection PyTypeChecker
-                    _coefs = _robust_fit(X, y)
-                    _coefs[0] *= winsor_threshold
+                    try:
+                        # noinspection PyTypeChecker
+                        _coefs = _robust_fit(X, y)
+                        _coefs[0] *= winsor_threshold
+                    except np.linalg.LinAlgError:
+                        logger.warning(
+                            f"Stream {stream.stream_id}: "
+                            f"Clock offsets {range_i} cannot be used for synchronization"
+                        )
+                        _coefs = [0, 0]
                     coef.append(_coefs)
                 else:
+                    # Intercept for single sample segments
                     coef.append((clock_values[range_i[0]], 0))
 
             # Apply the correction to all time-stamps
@@ -714,12 +722,20 @@ def _clock_sync(
                     else:
                         # Include all time-stamps from the last break until the end
                         ts_stop = len(stream.time_stamps)
-                    stream.clock_segments.append((ts_start, ts_stop - 1))
-                    ts_slice = slice(ts_start, ts_stop)
-                    ts_start = ts_stop
-                    stream.time_stamps[ts_slice] += (
-                        coef_i[0] + coef_i[1] * stream.time_stamps[ts_slice]
-                    )
+                    if ts_start == ts_stop:
+                        logger.warning(
+                            (
+                                f"Stream {stream.stream_id}: "
+                                f"No samples in clock offsets {range_i}, skipping..."
+                            )
+                        )
+                    else:
+                        stream.clock_segments.append((ts_start, ts_stop - 1))
+                        ts_slice = slice(ts_start, ts_stop)
+                        ts_start = ts_stop
+                        stream.time_stamps[ts_slice] += (
+                            coef_i[0] + coef_i[1] * stream.time_stamps[ts_slice]
+                        )
     return streams
 
 

test/test_clock_sync.py

@@ -1,10 +1,11 @@
+import logging
+
 import numpy as np
 import pytest
 from pyxdf.pyxdf import _clock_sync
 
 from mock_data_stream import MockStreamData
 
-
 # No clock resets
 
 
@@ -172,6 +173,86 @@ def test_sync_no_resets_bounds_jitter(
     np.testing.assert_equal(streams[1].clock_segments, [(0, len(time_stamps) - 1)])
 
 
+# Invalid clock offsets: LinAlgError
+
+
+def test_clock_sync_error_keep_segment(caplog):
+    caplog.set_level(logging.WARNING)
+    expected = [0, 1, 2, 3, 4] + [15, 16, 17, 18, 19]
+    time_stamps = np.arange(0, len(expected))
+    # Clock offsets (0, 1) are unusable: LinAlgError
+    clock_times = [0, 0] + [10, 15]
+    clock_values = [0, 0] + [10, 10]
+    streams = {
+        1: MockStreamData(
+            time_stamps=time_stamps,
+            clock_times=clock_times,
+            clock_values=clock_values,
+        )
+    }
+    _clock_sync(
+        streams,
+        reset_threshold_stds=0,
+        reset_threshold_seconds=4,
+        reset_threshold_offset_stds=0,
+        reset_threshold_offset_seconds=9,
+    )
+    assert "Clock offsets (0, 1) cannot be used for synchronization" in caplog.text
+    np.testing.assert_allclose(
+        streams[1].time_stamps,
+        expected,
+    )
+    np.testing.assert_equal(streams[1].time_series[:, 0], time_stamps)
+    np.testing.assert_equal(streams[1].clock_times, clock_times)
+    np.testing.assert_equal(streams[1].clock_values, clock_values)
+    np.testing.assert_equal(
+        streams[1].clock_segments,
+        [
+            (0, 4),
+            (5, 9),
+        ],
+    )
+
+
+def test_clock_sync_error_skip_segment(caplog):
+    caplog.set_level(logging.WARNING)
+    expected = [15, 16, 17, 18, 19, 20, 21, 22, 23, 24]
+    # All time-stamps should be synchronized by clock offsets (2, 3)
+    time_stamps = np.arange(5, 5 + len(expected))
+    # Clock offsets (0, 1) are unusable: LinAlgError
+    clock_times = [0, 0] + [10, 15]
+    clock_values = [0, 0] + [10, 10]
+    streams = {
+        1: MockStreamData(
+            time_stamps=time_stamps,
+            clock_times=clock_times,
+            clock_values=clock_values,
+        )
+    }
+    _clock_sync(
+        streams,
+        reset_threshold_stds=0,
+        reset_threshold_seconds=4,
+        reset_threshold_offset_stds=0,
+        reset_threshold_offset_seconds=9,
+    )
+    assert "Clock offsets (0, 1) cannot be used for synchronization" in caplog.text
+    assert "No samples in clock offsets (0, 1), skipping..." in caplog.text
+    np.testing.assert_allclose(
+        streams[1].time_stamps,
+        expected,
+    )
+    np.testing.assert_equal(streams[1].time_series[:, 0], time_stamps)
+    np.testing.assert_equal(streams[1].clock_times, clock_times)
+    np.testing.assert_equal(streams[1].clock_values, clock_values)
+    np.testing.assert_equal(
+        streams[1].clock_segments,
+        [
+            (0, 9),
+        ],
+    )
+
+
 # Clock resets