parameters.clarity tests inital

Author: sbch22

tests/test_parameters_clarity.py

@@ -3,119 +3,73 @@
 import pyfar as pf
 from pyrato.parameters import clarity
 
-# Input types, Output type
-# -------------------
-def test_accepts_signal_object():
-    sig = pf.signals.impulse(
+
+def test_clarity_accepts_signal_object_and_returns_correct_type():
+    impulse_signal = pf.signals.impulse(
         n_samples=128, delay=0, amplitude=1, sampling_rate=44100
     )
-    result = clarity(sig, early_time_limit=80)
+    result = clarity(impulse_signal, early_time_limit=1)
 
     assert isinstance(result, (float, np.ndarray))
-    assert result.shape == sig.cshape
-
-def test_rejects_non_signal_input():
-    with pytest.raises(AttributeError):  
-        clarity(np.array([1,2,3]))
+    assert result.shape == impulse_signal.cshape
 
 
+def test_clarity_rejects_non_signal_input():
+    with pytest.raises(AttributeError):  
+        clarity(np.array([1, 2, 3]))
 
-# Multichannel shape
-# -------------------
-def test_multichannel_shape():
-    brir = pf.signals.files.binaural_room_impulse_response(diffuse_field_compensation=False, sampling_rate=48000)
 
+def test_clarity_preserves_multichannel_shape():
+    brir = pf.signals.files.binaural_room_impulse_response(
+        diffuse_field_compensation=False, 
+        sampling_rate=48000
+    )
     output = clarity(brir, early_time_limit=80)
 
     assert brir.cshape == output.shape
 
 
-
-
-# Edge cases
-# -------------------
-def test_empty_signal_returns_nan():
-    sig = pf.Signal(np.zeros(16), 44100)
-    result = clarity(sig, early_time_limit=80)
+def test_clarity_returns_nan_for_zero_signal():
+    silent_signal = pf.Signal(np.zeros(4096), 44100)
+    result = clarity(silent_signal)
     assert np.isnan(result) or result == -np.inf
 
 
-def test_unusual_time_limit_warns():
-    sig = pf.signals.impulse( n_samples=128, delay=0, amplitude=1, sampling_rate=44100)
+def test_clarity_warns_for_unusually_short_time_limit():
+    impulse_signal = pf.signals.impulse(
+        n_samples=128, delay=0, amplitude=1, sampling_rate=44100
+    )
     with pytest.warns(UserWarning):
-        clarity(sig, early_time_limit=0.05)
-
-
-
-
-# Energie- vs. Amplitudensignal
-# -------------------
-# def test_energy_signal_vs_amplitude_signal():
-#     # gleicher Inhalt, einmal als "energy" markiert
-#     sig_amp = pf.signals.impulse( n_samples=128, delay=0, amplitude=1, sampling_rate=44100)
-#     sig_energy = pf.Signal(sig_amp.time**2, 44100)
-
-#     # label "energy" automatically assigned?
-#     result_amp = clarity(sig_amp, early_time_limit=80)
-#     result_energy = clarity(sig_energy, early_time_limit=80)
+        clarity(impulse_signal, early_time_limit=0.05)
 
-#     # same values
-#     np.testing.assert_allclose(result_amp, result_energy)
 
-
-# Reference cases
-# -------------------
-def test_known_reference_case():
-    # Artificial signal: 2 Samples early = 2 energy, 2 Samples late = 2 energy
-    data = np.array([1, 1, 1, 1] + [0]*124)
-    sig = pf.Signal(data, sampling_rate=1000)
-    result = clarity(sig, early_time_limit=2)  # 2ms limit -> even early/late division
-    # Early = Late => log10(1) = 0 dB
-    assert np.isclose(result, 0.0, atol=1e-6)
-
-def load_c80_from_rew(file_path):
-    c80_values = []
-
-    with open(file_path, "r") as f:
-        for line in f:
-            line = line.strip()
-            if not line or not line[0].isdigit():  # nur Zeilen, die mit Zahl anfangen
-                continue
-            parts = [p.strip() for p in line.split(",")]
-            if len(parts) < 16:
-                continue
-            try:
-                c80 = float(parts[15])
-                c80_values.append(c80)
-            except ValueError:
-                continue
-
-    return np.array(c80_values, dtype=np.float32)
-
-
-# test with reference impulse response C80
-def test_reference_impulse_response_filtered():
-    rir = pf.signals.files.room_impulse_response(sampling_rate=48000)
-
-    # filter into octave bands
-    rir_octave_filtered = pf.dsp.filter.fractional_octave_bands(rir, num_fractions=1)
-    # rir_third_octave_filtered = pf.dsp.filter.fractional_octave_bands(rir, num_fractions=3)
-
-    c80_rir_octave_bands = clarity(rir_octave_filtered, early_time_limit=80)
-
-    # tolerance?
-    REW_c80_rir_octave_band = load_c80_from_rew("tests/test_data/example_rir48kHz_REWdata.txt")
+def test_clarity_calculates_known_reference_value():
+    # 2 samples early energy = 2, 2 samples late energy = 2 → ratio = 1 → 0 dB
+    signal_data = np.concatenate(([1, 1, 1, 1], np.zeros(124)))
+    test_signal = pf.Signal(signal_data, sampling_rate=1000)
 
+    result = clarity(test_signal, early_time_limit=2)
 
-    assert np.allclose(REW_c80_rir_octave_band, c80_rir_octave_bands, atol=0.01)
-
+    assert np.isclose(result, 0.0, atol=1e-6)
 
 
+def test_clarity_matches_analytical_geometric_decay_solution():
+    sampling_rate = 1000
+    decay_factor = 0.9
+    total_samples = 200
+    early_cutoff = 80  # ms
 
-# test with reference impulse response C50
+    time_axis = np.arange(total_samples)
+    decaying_signal = pf.Signal(
+        decay_factor ** time_axis, 
+        sampling_rate=sampling_rate
+    )
 
+    squared_factor = decay_factor ** 2
+    early_energy = (1 - squared_factor ** early_cutoff) / (1 - squared_factor)
+    late_energy = (squared_factor ** early_cutoff - squared_factor ** total_samples) / (1 - squared_factor)
+    expected_db = 10 * np.log10(early_energy / late_energy)
 
-# test with reference impulse response C1000
-# what happens if early_time limit is longer than IR?
-# what happens if early_time_limit is out of logical bounds?
+    result = clarity(decaying_signal, early_time_limit=early_cutoff)
 
+    assert np.isclose(result, expected_db, atol=1e-6)