test_frequency_simple.py

#!/usr/bin/env python3
"""
Vereinfachte Version des Frequenzgang-Analyzers für Tests
"""

import tkinter as tk
from tkinter import messagebox
import numpy as np
import subprocess
import os

class SimpleFrequencyTest:
    def __init__(self, root):
        self.root = root
        self.root.title("🔬 Frequenzgang-Analyzer Test")
        self.root.geometry("400x300")
        
        # Titel
        title = tk.Label(root, text="🎤 Frequenzgang-Analyse", font=('Arial', 14, 'bold'))
        title.pack(pady=10)
        
        # Info
        info = tk.Label(root, text="Test-Version für Mikrofonqualitätsbewertung", 
                       font=('Arial', 10))
        info.pack(pady=5)
        
        # Status
        self.status_var = tk.StringVar(value="Bereit für Test...")
        status_label = tk.Label(root, textvariable=self.status_var, 
                               font=('Arial', 9), fg='blue')
        status_label.pack(pady=10)
        
        # Buttons
        btn_frame = tk.Frame(root)
        btn_frame.pack(pady=20)
        
        test_btn = tk.Button(btn_frame, text="🧪 Abhängigkeiten testen", 
                           command=self.test_dependencies, bg='lightblue')
        test_btn.pack(pady=5, fill=tk.X)
        
        demo_btn = tk.Button(btn_frame, text="📈 Demo-Frequenzgang generieren", 
                           command=self.generate_demo, bg='lightgreen')
        demo_btn.pack(pady=5, fill=tk.X)
        
        close_btn = tk.Button(btn_frame, text="❌ Schließen", 
                            command=root.quit, bg='lightcoral')
        close_btn.pack(pady=5, fill=tk.X)
        
    def test_dependencies(self):
        """Testet alle erforderlichen Dependencies"""
        try:
            self.status_var.set("Teste Dependencies...")
            self.root.update()
            
            # NumPy
            import numpy
            numpy_version = numpy.__version__
            
            # SciPy (falls verfügbar)
            try:
                from scipy import signal
                scipy_available = "✅ SciPy verfügbar"
            except ImportError:
                scipy_available = "❌ SciPy nicht verfügbar"
            
            # Matplotlib (falls verfügbar)
            try:
                import matplotlib
                matplotlib_available = "✅ Matplotlib verfügbar"
            except ImportError:
                matplotlib_available = "❌ Matplotlib nicht verfügbar"
                
            # PyAudio (falls verfügbar)
            try:
                import pyaudio
                pyaudio_available = "✅ PyAudio verfügbar"
            except ImportError:
                pyaudio_available = "❌ PyAudio nicht verfügbar"
                
            result = f"""DEPENDENCY-TEST:

✅ NumPy: {numpy_version}
{scipy_available}
{matplotlib_available}
{pyaudio_available}

STATUS: Test abgeschlossen"""
            
            messagebox.showinfo("Dependency-Test", result)
            self.status_var.set("Test abgeschlossen")
            
        except Exception as e:
            messagebox.showerror("Fehler", f"Test fehlgeschlagen:\n{str(e)}")
            self.status_var.set("Test fehlgeschlagen")
    
    def generate_demo(self):
        """Generiert einen Demo-Frequenzgang"""
        try:
            self.status_var.set("Generiere Demo...")
            self.root.update()
            
            # Demo-Frequenzen (20Hz bis 20kHz)
            frequencies = np.logspace(1, 4.3, 100)  # 10Hz bis ~20kHz
            
            # Simuliere Mikrofonfrequenzgang
            response = np.ones_like(frequencies)
            
            # Typische Mikrofoncharakteristik simulieren
            # Hochpass bei niedrigen Frequenzen
            response[frequencies < 80] *= (frequencies[frequencies < 80] / 80) ** 2
            
            # Resonanz bei ~3kHz (typisch für Kondensatormikrofone)
            resonance = 1 + 0.3 * np.exp(-((frequencies - 3000) / 1000) ** 2)
            response *= resonance
            
            # Rolloff bei hohen Frequenzen
            response[frequencies > 10000] *= np.exp(-(frequencies[frequencies > 10000] - 10000) / 8000)
            
            # Konvertiere zu dB
            response_db = 20 * np.log10(response)
            
            # Einfache Auswertung
            speech_range = (frequencies >= 300) & (frequencies <= 3400)
            speech_response = response_db[speech_range]
            speech_variation = np.max(speech_response) - np.min(speech_response)
            
            # Qualitätsbewertung
            if speech_variation < 3:
                quality = "🟢 AUSGEZEICHNET"
            elif speech_variation < 6:
                quality = "🟡 GUT"
            elif speech_variation < 10:
                quality = "🟠 MÄSSIG"
            else:
                quality = "🔴 SCHLECHT"
            
            result = f"""🔬 DEMO-FREQUENZGANG ANALYSE

📊 ERGEBNISSE:
• Sprachbereich-Variation: {speech_variation:.1f} dB
• Qualitätsbewertung: {quality}
• Resonanzspitze: ~3000 Hz
• Tiefpass-Grenze: ~10000 Hz

💡 INTERPRETATION:
Ein gutes Mikrofon für Spracherkennung sollte 
im Bereich 300-3400 Hz möglichst gleichmäßig 
reagieren (< 3dB Variation).

🎯 EMPFEHLUNG:
Die Demo zeigt eine typische Kondensatormikrofon-
Charakteristik. Für bessere Vosk-Erkennung könnte 
ein EQ bei 3kHz sinnvoll sein."""

            messagebox.showinfo("Demo-Frequenzgang", result)
            self.status_var.set("Demo generiert - siehe Popup")
            
        except Exception as e:
            messagebox.showerror("Fehler", f"Demo-Generierung fehlgeschlagen:\n{str(e)}")
            self.status_var.set("Demo fehlgeschlagen")

if __name__ == "__main__":
    root = tk.Tk()
    app = SimpleFrequencyTest(root)
    root.mainloop()