cognitive_mapping_probe/signal_analysis.py

import numpy as np
from scipy.fft import rfft, rfftfreq
from scipy.signal import hilbert
from typing import Dict, 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]:
    """
    Führt eine fortgeschrittene Signalverarbeitungs-Analyse auf der Zeitreihe der
    State Deltas durch, um den "kognitiven Frequenz-Fingerabdruck" zu extrahieren.
    """
    if len(state_deltas) < 2:
        return {}

    # 1. Fourier-Analyse (FFT)
    n = len(state_deltas)
    yf = rfft(state_deltas - np.mean(state_deltas)) # Entferne DC-Offset
    xf = rfftfreq(n, 1 / sampling_rate)
    
    power_spectrum = np.abs(yf)**2
    
    # 2. Extrahiere Metriken aus dem Spektrum
    if len(power_spectrum) > 1:
        # Dominante Frequenz (ohne die 0-Hz-Komponente)
        dominant_freq_index = np.argmax(power_spectrum[1:]) + 1
        dominant_frequency = xf[dominant_freq_index]

        # Spektrale Entropie (Maß für die Komplexität/Rauschhaftigkeit)
        prob_dist = power_spectrum / np.sum(power_spectrum)
        prob_dist = prob_dist[prob_dist > 0] # Vermeide log(0)
        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),
    }

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:
        return np.array([]), np.array([])
        
    n = len(state_deltas)
    yf = rfft(state_deltas - np.mean(state_deltas))
    xf = rfftfreq(n, 1.0)
    
    power_spectrum = np.abs(yf)**2
    return xf, power_spectrum