Update cognitive_mapping_probe/signal_analysis.py

cognitive_mapping_probe/signal_analysis.py

@@ -1,56 +1,55 @@
 import numpy as np
 from scipy.fft import rfft, rfftfreq
-from scipy.signal import hilbert
-from typing import Dict, Tuple
+from typing import Dict, Optional, Tuple
 
 def analyze_cognitive_signal(
     state_deltas: np.ndarray, 
-    sampling_rate: float = 1.0  # Wir nehmen an, dass jeder "Step" eine Zeiteinheit ist
-) -> Dict[str, float]:
+    sampling_rate: float = 1.0
+) -> Dict[str, Optional[float]]:
     """
     Führt eine fortgeschrittene Signalverarbeitungs-Analyse auf der Zeitreihe der
-    State Deltas durch, um den "kognitiven Frequenz-Fingerabdruck" zu extrahieren.
+    State Deltas durch und gibt hardware-unabhängige Metriken zurück.
     """
-    if len(state_deltas) < 2:
-        return {}
+    if len(state_deltas) < 10:
+        return {
+            "dominant_period_steps": None,
+            "spectral_entropy": None,
+        }
 
-    # 1. Fourier-Analyse (FFT)
     n = len(state_deltas)
-    yf = rfft(state_deltas - np.mean(state_deltas)) # Entferne DC-Offset
+    yf = rfft(state_deltas - np.mean(state_deltas))
     xf = rfftfreq(n, 1 / sampling_rate)
     
     power_spectrum = np.abs(yf)**2
     
-    # 2. Extrahiere Metriken aus dem Spektrum
+    dominant_frequency = None
+    spectral_entropy = None
+    dominant_period_steps = None
+
     if len(power_spectrum) > 1:
-        # Dominante Frequenz (ohne die 0-Hz-Komponente)
+        # Finde dominante Frequenz (ohne 0-Hz)
         dominant_freq_index = np.argmax(power_spectrum[1:]) + 1
         dominant_frequency = xf[dominant_freq_index]
 
-        # Spektrale Entropie (Maß für die Komplexität/Rauschhaftigkeit)
+        # FINALE KORREKTUR: Berechne die Periodendauer in "Steps"
+        if dominant_frequency > 1e-9: # Schutz vor Division durch Null
+            dominant_period_steps = 1 / dominant_frequency
+
+        # Berechne Spektrale Entropie
         prob_dist = power_spectrum / np.sum(power_spectrum)
-        prob_dist = prob_dist[prob_dist > 0] # Vermeide log(0)
+        prob_dist = prob_dist[prob_dist > 1e-12]
         spectral_entropy = -np.sum(prob_dist * np.log2(prob_dist))
-    else:
-        dominant_frequency = 0.0
-        spectral_entropy = 0.0
-
-    # 3. Hilbert-Transformation zur Phasen-Analyse (hier nur als Beispiel,
-    # da die Interpretation komplex ist und im UI schwer darstellbar)
-    # analytic_signal = hilbert(state_deltas)
-    # instantaneous_phase = np.unwrap(np.angle(analytic_signal))
-    # instantaneous_frequency = (np.diff(instantaneous_phase) / (2.0*np.pi) * sampling_rate)
 
     return {
-        "dominant_frequency": float(dominant_frequency),
-        "spectral_entropy": float(spectral_entropy),
+        "dominant_period_steps": float(dominant_period_steps) if dominant_period_steps is not None else None,
+        "spectral_entropy": float(spectral_entropy) if spectral_entropy is not None else None,
     }
 
 def get_power_spectrum_for_plotting(state_deltas: np.ndarray) -> Tuple[np.ndarray, np.ndarray]:
     """
     Berechnet das Leistungsspektrum speziell für die Visualisierung.
     """
-    if len(state_deltas) < 2:
+    if len(state_deltas) < 10:
         return np.array([]), np.array([])
         
     n = len(state_deltas)