add tests for waveform, and add interpolation

Author: SBlokhuizen

tests/tendencies/test_piecewise.py

@@ -100,7 +100,7 @@ def test_get_value_interpolate():
     tendency = PiecewiseLinearTendency(
         user_time=np.array([1, 2, 3]), user_value=np.array([2, 4, 8])
     )
-    time, values = tendency.get_value(time=[1.0, 1.5, 2.0, 2.5, 3.0])
+    time, values = tendency.get_value(np.array([1.0, 1.5, 2.0, 2.5, 3.0]))
     assert np.all(time == [1.0, 1.5, 2.0, 2.5, 3.0])
     assert np.allclose(values, [2.0, 3.0, 4.0, 6.0, 8.0])
     assert not tendency.annotations
@@ -109,15 +109,15 @@ def test_get_value_interpolate():
     tendency = PiecewiseLinearTendency(
         user_time=np.array([1, 2, 3]), user_value=np.array([2, 4, 8])
     )
-    time, values = tendency.get_value(time=[0.5, 1.5, 2.0, 2.5, 3.0])
+    time, values = tendency.get_value(np.array([0.5, 1.5, 2.0, 2.5, 3.0]))
     assert np.allclose(values, [2.0, 3.0, 4.0, 6.0, 8.0])
     assert tendency.annotations
 
     # Request after time range
     tendency = PiecewiseLinearTendency(
         user_time=np.array([1, 2, 3]), user_value=np.array([2, 4, 8])
     )
-    time, values = tendency.get_value(time=[1.0, 1.5, 2.0, 2.5, 3.5])
+    time, values = tendency.get_value(np.array([1.0, 1.5, 2.0, 2.5, 3.5]))
     assert np.allclose(values, [2.0, 3.0, 4.0, 6.0, 8.0])
     assert tendency.annotations
 

tests/test_waveform.py

@@ -0,0 +1,193 @@
+import numpy as np
+import pytest
+
+from waveform_editor.tendencies.constant import ConstantTendency
+from waveform_editor.tendencies.linear import LinearTendency
+from waveform_editor.tendencies.periodic.sine_wave import SineWaveTendency
+from waveform_editor.tendencies.smooth import SmoothTendency
+from waveform_editor.waveform import Waveform
+
+
+def test_empty():
+    waveform = Waveform()
+    assert waveform.tendencies == []
+    assert waveform.annotations == []
+
+
+@pytest.fixture
+def waveform_list():
+    return [
+        {"type": "linear", "from": 0, "to": 8, "duration": 5, "line_number": 1},
+        {
+            "type": "sine-wave",
+            "base": 8,
+            "amplitude": 2,
+            "frequency": 1,
+            "duration": 4,
+            "line_number": 2,
+        },
+        {"type": "constant", "value": 8, "duration": 3, "line_number": 3},
+        {"type": "smooth", "from": 8, "to": 0, "duration": 2, "line_number": 4},
+    ]
+
+
+@pytest.fixture
+def waveform(waveform_list):
+    return Waveform(waveform=waveform_list)
+
+
+def test_annotations(waveform_list):
+    """Test if annotations of tendencies are passed to waveform's annotations."""
+    waveform = Waveform(waveform=waveform_list)
+    assert not waveform.annotations
+
+    waveform_list[0]["type"] = "sine-wav"
+    waveform = Waveform(waveform=waveform_list)
+    assert waveform.annotations
+
+
+def test_tendencies(waveform):
+    """Test if tendencies are of correct type."""
+    assert isinstance(waveform.tendencies[0], LinearTendency)
+    assert isinstance(waveform.tendencies[1], SineWaveTendency)
+    assert isinstance(waveform.tendencies[2], ConstantTendency)
+    assert isinstance(waveform.tendencies[3], SmoothTendency)
+
+
+def test_get_value(waveform):
+    """Test if get_value returns the correct values."""
+    times = np.linspace(0, 14, 15)
+    _, values = waveform.get_value(times)
+    expected = [0, 1.6, 3.2, 4.8, 6.4, 8, 8, 8, 8, 8, 8, 8, 8, 4, 0]
+    assert np.allclose(values, expected)
+
+
+def test_get_derivative(waveform):
+    """Test if get_derivative returns the correct values."""
+    times = np.linspace(0, 14, 15)
+    derivatives = waveform.get_derivative(times)
+    fpi = 4 * np.pi
+    expected = [1.6, 1.6, 1.6, 1.6, 1.6, fpi, fpi, fpi, fpi, 0, 0, 0, 0, -6, 0]
+    assert np.allclose(derivatives, expected)
+
+
+def test_length(waveform):
+    """Test if calc_length returns the correct value."""
+    assert waveform.calc_length() == 14
+
+
+def test_gap():
+    """Test if gap between tendency is interpolated."""
+    gap_waveform = [
+        {"type": "constant", "value": 3, "start": 0, "end": 2, "line_number": 1},
+        {"type": "constant", "value": 5, "start": 4, "end": 5, "line_number": 2},
+    ]
+    waveform = Waveform(waveform=gap_waveform)
+    assert waveform.annotations
+    times, values = waveform.get_value()
+    assert np.allclose(times, [0, 2, 4, 5])
+    assert np.allclose(values, [3, 3, 5, 5])
+
+    expected = [3, 3, 3, 3, 3, 3.5, 4, 4.5, 5, 5, 5]
+    _, values = waveform.get_value(np.linspace(0, 5, 11))
+    assert np.allclose(values, expected)
+
+
+def test_gap_derivative():
+    """Test if derivative of gap between tendency is set to zero."""
+    gap_waveform = [
+        {"type": "constant", "value": 3, "start": 0, "end": 2, "line_number": 1},
+        {"type": "constant", "value": 5, "start": 4, "end": 5, "line_number": 2},
+    ]
+    waveform = Waveform(waveform=gap_waveform)
+    assert waveform.annotations
+
+    values = waveform.get_derivative(np.linspace(0, 5, 11))
+    assert np.allclose(values, np.zeros(11))
+
+
+def test_get_value_outside(waveform):
+    """Test if values outside of range are clipped."""
+    gap_waveform = [
+        {"type": "constant", "value": 3, "start": 0, "end": 2, "line_number": 1},
+        {"type": "constant", "value": 5, "start": 4, "end": 5, "line_number": 2},
+    ]
+    gap_waveform = Waveform(waveform=gap_waveform)
+    # test requesting values outside of time range
+    _, gap_values = gap_waveform.get_value(np.linspace(-1, 0, 4))
+    _, values = waveform.get_value(np.linspace(-5, 0, 6))
+    assert np.allclose(gap_values, [3, 3, 3, 3])
+    assert np.allclose(values, np.zeros(6))
+
+    # test requesting values outside of time range
+    _, gap_values = gap_waveform.get_value(np.linspace(5, 6, 4))
+    _, values = waveform.get_value(np.linspace(14, 18, 5))
+    assert np.allclose(gap_values, [5, 5, 5, 5])
+    assert np.allclose(values, np.zeros(5))
+
+
+def test_get_derivative_outside(waveform):
+    """Test if derivatives outside of range are set to zero."""
+    gap_waveform = [
+        {"type": "linear", "from": 3, "to": 7, "start": 0, "end": 2, "line_number": 1},
+        {
+            "type": "linear",
+            "from": 6,
+            "to": 3,
+            "start": 4,
+            "end": 5,
+            "line_number": 2,
+        },
+    ]
+    gap_waveform = Waveform(waveform=gap_waveform)
+    # test requesting values outside of time range
+    gap_derivatives = gap_waveform.get_derivative(np.linspace(-1, 0, 4))
+    derivatives = waveform.get_derivative(np.linspace(-5, 0, 6))
+    assert np.allclose(gap_derivatives, [0, 0, 0, 2])
+    assert np.allclose(derivatives, [0, 0, 0, 0, 0, 1.6])
+
+    # test requesting values outside of time range
+    gap_derivatives = gap_waveform.get_derivative(np.linspace(5, 6, 4))
+    derivatives = waveform.get_derivative(np.linspace(14, 18, 5))
+    assert np.allclose(gap_derivatives, [-3, 0, 0, 0])
+    assert np.allclose(derivatives, np.zeros(5))
+
+
+def test_overlap():
+    """Test values if tendencies overlap."""
+    overlap_waveform = [
+        {"type": "constant", "value": 3, "start": 0, "end": 2, "line_number": 1},
+        {"type": "constant", "value": 5, "start": 1, "end": 3, "line_number": 2},
+    ]
+    waveform = Waveform(waveform=overlap_waveform)
+    assert waveform.annotations
+    times, values = waveform.get_value()
+    assert np.allclose(times, [0, 2, 1, 3])
+    assert np.allclose(values, [3, 3, 5, 5])
+
+    # Later tendencies take precedence
+    expected = [3, 3, 5, 5, 5, 5, 5]
+    _, values = waveform.get_value(np.linspace(0, 3, 7))
+    assert np.allclose(values, expected)
+
+
+def test_overlap_derivatives():
+    """Test derivatives if tendencies overlap."""
+    overlap_waveform = [
+        {"type": "linear", "from": 3, "to": 7, "start": 0, "end": 2, "line_number": 1},
+        {
+            "type": "linear",
+            "from": 6,
+            "to": 3,
+            "start": 1,
+            "end": 3,
+            "line_number": 2,
+        },
+    ]
+    waveform = Waveform(waveform=overlap_waveform)
+    assert waveform.annotations
+
+    # Later tendencies take precedence
+    expected = [2, 2, -1.5, -1.5, -1.5, -1.5, -1.5]
+    values = waveform.get_derivative(np.linspace(0, 3, 7))
+    assert np.allclose(values, expected)

waveform_editor/tendencies/repeat.py

@@ -33,12 +33,20 @@ def __init__(self, **kwargs):
         self.waveform.tendencies[0].set_previous_tendency(self.waveform.tendencies[-1])
         self.waveform.tendencies[-1].set_next_tendency(self.waveform.tendencies[0])
 
-        _, self.start_value = self.get_value(self.start)
-        self.start_derivative = self.get_derivative(self.start)
-        _, self.end_value = self.get_value(self.end)
-        self.end_derivative = self.get_derivative(self.end)
+        self._set_bounds()
         self.annotations.add_annotations(self.waveform.annotations)
 
+    def _set_bounds(self):
+        """Sets the start and end values, as well as derivatives"""
+        _, start_values = self.get_value(np.array([self.start]))
+        self.start_value = start_values[0]
+        start_derivatives = self.get_derivative(np.array([self.start]))
+        self.start_derivative = start_derivatives[0]
+        _, end_values = self.get_value(np.array([self.end]))
+        self.end_value = end_values[0]
+        end_derivatives = self.get_derivative(np.array([self.end]))
+        self.end_derivative = end_derivatives[0]
+
     def get_value(
         self, time: Optional[np.ndarray] = None
     ) -> tuple[np.ndarray, np.ndarray]:

waveform_editor/waveform.py

@@ -87,7 +87,7 @@ def _evaluate_tendencies(self, time, eval_derivatives=False):
         Returns:
             numpy array containing the computed values.
         """
-        values = np.zeros_like(time, dtype=float)
+        values = np.full_like(time, np.nan, dtype=float)
 
         for tendency in self.tendencies:
             mask = (time >= tendency.start) & (time <= tendency.end)
@@ -97,8 +97,64 @@ def _evaluate_tendencies(self, time, eval_derivatives=False):
                 else:
                     _, values[mask] = tendency.get_value(time[mask])
 
+        # If there still remain nans in the values, this means that there are gaps
+        # between the tendencies. In this case we linearly interpolate between the gap
+        # values
+        for idx, t in enumerate(time):
+            if np.isnan(values[idx]):
+                # The derivatives of interpolated gaps are not calculated
+                if eval_derivatives:
+                    values[idx] = 0
+                else:
+                    values[idx] = self._interpolate_gap(t)
+
         return values
 
+    def _interpolate_gap(self, t):
+        """Interpolates the value for a given time t based on the nearest tendencies.
+        Also extrapolates the values if the time requested falls before the first, or
+        after the last tendency.
+
+        Args:
+            t: The time for which the value needs to be interpolated.
+
+        Returns:
+            The interpolated value.
+        """
+        # Find nearest tendencies before and after time t
+        prev_tendency = max(
+            (tend for tend in self.tendencies if tend.end <= t),
+            default=None,
+            key=lambda tend: tend.end,
+        )
+        next_tendency = min(
+            (tend for tend in self.tendencies if tend.start >= t),
+            default=None,
+            key=lambda tend: tend.start,
+        )
+
+        if prev_tendency and next_tendency:
+            val_end = prev_tendency.end_value
+            val_start = next_tendency.start_value
+
+            return np.interp(
+                t, [prev_tendency.end, next_tendency.start], [val_end, val_start]
+            )
+
+        # Handle extrapolation if t is before the first or after the last tendency
+        if prev_tendency is None:
+            next_tendency = self.tendencies[0]
+            val_start = next_tendency.start_value
+            return val_start
+
+        if next_tendency is None:
+            prev_tendency = self.tendencies[-1]
+            val_end = prev_tendency.end_value
+            return val_end
+
+        # If no valid interpolation or extrapolation can be performed, return 0
+        return 0.0
+
     def calc_length(self):
         """Returns the length of the waveform."""
         return self.tendencies[-1].end - self.tendencies[0].start