Allgemeine Beschreibung

Der Code „VideoNoiseDetector“ dient zur Analyse von Videos auf Bildrauschen. Er wurde aus einem ursprünglichen Skript in eine Klassenstruktur überführt. Der Nutzer startet die Analyse, indem er den Pfad zu einem Video eingibt. Das Programm untersucht jedes Bild des Videos und sucht nach Gesichtern. Gefundene Gesichter werden in kleinere Bereiche aufgeteilt, um Rauschen zu prüfen.

Funktionsweise

Das Programm erkennt Bereiche mit starkem Rauschen, also vielen Pixelunterschieden. Diese Stellen werden mit roten Rechtecken im Video markiert. Das bearbeitete Video wird im Ordner „analyse/video“ abgespeichert. Während der Verarbeitung zeigt ein Fenster die aktuellen Bilder live an. Nach der Analyse gibt es eine Zusammenfassung der Rauschmenge. Ein Diagramm zeigt, an welchen Stellen im Video das meiste Rauschen auftrat.

Technische Grundlagen

Der Code verwendet Python und gängige Bibliotheken wie OpenCV, NumPy und Matplotlib. Er ist so gestaltet, dass er effizient arbeitet und wenig Speicher beansprucht. Die Gesichtserkennung basiert auf einer vordefinierten OpenCV-Datei. Die Rauschanalyse erfolgt durch Vergleich der Pixelwerte in den Gesichtsbereichen.

Mögliche Einsatzbereiche

Der Code kann zur Qualitätsprüfung von Überwachungsaufnahmen genutzt werden. Er eignet sich auch, um Veränderungen in Videos zu erkennen, etwa durch Bearbeitung. Für private Anwendungen kann er alte Videos untersuchen. Die Analyse ist auf einfache Szenarien ausgelegt und nicht für komplexe Bearbeitungen optimiert.

Installation und Nutzung

Die Installation erfordert das Herunterladen der Bibliotheken OpenCV, NumPy und Matplotlib über pip. Danach speichert man den Code in eine Datei, z. B. „video_noise_detector.py“. Zum Starten führt man das Skript aus und gibt den Pfad zu einem Video ein. Das Programm erstellt dann das Analysevideo und zeigt die Ergebnisse an.

Einschränkungen

Der Code funktioniert am besten mit Videos, die klare Gesichter enthalten. Ohne Gesichter wird keine Rauschanalyse durchgeführt. Die Genauigkeit hängt von der Videoqualität und den Einstellungen ab. Er ist nicht für Echtzeitverarbeitung oder sehr große Dateien optimiert.

Quellcode

import cv2
import numpy as np
import os
from matplotlib import pyplot as plt
from typing import Tuple, List

class VideoNoiseDetector:
    def __init__(self, video_path: str, threshold: float = 1.5, grid_size: Tuple[int, int] = (50, 50), 
                 top_n_frames: int = 5):
        self.video_path = video_path
        self.threshold = threshold
        self.grid_size = grid_size
        self.top_n_frames = top_n_frames
        self.face_cascade = cv2.CascadeClassifier(
            cv2.data.haarcascades + 'haarcascade_frontalface_default.xml'
        )
        self.output_folder = "analyse/video"

    def _process_frame(self, frame: np.ndarray) -> Tuple[List, np.ndarray]:
        """Verarbeitet einen einzelnen Frame und markiert Rauschbereiche."""
        gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
        faces = self.face_cascade.detectMultiScale(gray, 1.3, 5)
        noise_frames = []

        if len(faces) > 0:
            # Nur größtes Gesicht verwenden
            x, y, w, h = max(faces, key=lambda f: f[2] * f[3])
            face_roi = frame[y:y+h, x:x+w]
            
            # Effizientere Regionenaufteilung
            h_step, w_step = h // self.grid_size[0], w // self.grid_size[1]
            std_devs = np.zeros(self.grid_size)
            
            for i in range(self.grid_size[0]):
                for j in range(self.grid_size[1]):
                    region = face_roi[i*h_step:(i+1)*h_step, j*w_step:(j+1)*w_step]
                    std_devs[i, j] = np.std(region)

            face_avg_noise = np.mean(std_devs)
            noisy_regions = np.where(std_devs > self.threshold * face_avg_noise)
            
            for i, j in zip(*noisy_regions):
                noise_frames.append((i, j, (x, y, w, h)))
                x_start = x + j * w_step
                y_start = y + i * h_step
                cv2.rectangle(frame, (x_start, y_start), 
                            (x_start + w_step, y_start + h_step), 
                            (0, 0, 255), 2)

        return noise_frames, frame

    def analyze(self) -> None:
        """Analysiert das Video und speichert die Ergebnisse."""
        os.makedirs(self.output_folder, exist_ok=True)
        
        cap = cv2.VideoCapture(self.video_path)
        if not cap.isOpened():
            raise ValueError("Konnte Video nicht öffnen")
            
        fps = cap.get(cv2.CAP_PROP_FPS)
        frame_size = (int(cap.get(cv2.CAP_PROP_FRAME_WIDTH)), 
                     int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT)))
        total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))

        # Video Writer Setup
        file_name = os.path.splitext(os.path.basename(self.video_path))[0]
        output_path = os.path.join(self.output_folder, f"{file_name}_analyzed.mp4")
        fourcc = cv2.VideoWriter_fourcc(*'mp4v')
        out = cv2.VideoWriter(output_path, fourcc, fps, frame_size)

        frame_number = 0
        total_noise_frames = 0
        noise_counts = np.zeros(total_frames)
        top_frames = []

        while True:
            ret, frame = cap.read()
            if not ret:
                break

            noise_frames, annotated_frame = self._process_frame(frame.copy())
            noise_count = len(noise_frames)
            
            # Text overlay
            cv2.putText(annotated_frame, f"Pixelrauschen: {noise_count}", 
                       (10, 30), cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 255, 0), 2)
            
            out.write(annotated_frame)
            cv2.imshow("Frame", annotated_frame)
            
            # Statistiken
            total_noise_frames += noise_count
            noise_counts[frame_number] = noise_count
            if noise_count > 0:
                top_frames.append((frame_number, noise_count))
            
            if cv2.waitKey(1) & 0xFF == ord('q'):
                break
                
            frame_number += 1

        # Cleanup
        cap.release()
        out.release()
        cv2.destroyAllWindows()

        # Ergebnisse ausgeben
        self._print_results(total_frames, total_noise_frames, fps, output_path, top_frames)
        self._plot_noise_distribution(noise_counts)

    def _print_results(self, total_frames: int, total_noise: int, fps: float, 
                      output_path: str, top_frames: List) -> None:
        """Gibt die Analyseergebnisse aus."""
        print(f"Analysevideo gespeichert unter: {output_path}")
        print(f"Durchschnittliche Rauschframes pro Frame: {total_noise/total_frames:.2f}")
        print(f"Durchschnittliche Rauschframes pro Sekunde: {total_noise/fps:.2f}")
        
        print(f"\nTop {self.top_n_frames} Frames mit meisten Auffälligkeiten:")
        for frame_num, count in sorted(top_frames, key=lambda x: x[1], reverse=True)[:self.top_n_frames]:
            print(f"Frame {frame_num}: {count} Auffälligkeiten")

    def _plot_noise_distribution(self, noise_counts: np.ndarray) -> None:
        """Zeichnet die Rauschverteilung."""
        plt.plot(noise_counts)
        plt.xlabel('Frame Nummer')
        plt.ylabel('Anzahl Auffälligkeiten')
        plt.title('Zeitliche Verteilung der Auffälligkeiten')
        plt.grid(True)
        plt.show()

def main():
    video_path = input("Geben Sie den Pfad zur Videodatei ein: ")
    detector = VideoNoiseDetector(video_path)
    detector.analyze()

if __name__ == "__main__":
    main()

Installationsanleitung für den VideoNoiseDetector

Voraussetzungen

Für die Nutzung des Codes wird Python 3.8 oder höher benötigt. Eine funktionierende Videodatei (z. B. im MP4-Format) muss vorhanden sein. Optional kann ein Texteditor oder eine IDE wie PyCharm oder VS Code verwendet werden. Das Betriebssystem kann Windows, Linux oder macOS sein.

Python überprüfen

Prüfen Sie, ob Python installiert ist, indem Sie in der Kommandozeile oder im Terminal folgendes eingeben:

• python –version oder python3 –version Falls Python fehlt, laden Sie es von python.org herunter und installieren Sie es gemäß den Anweisungen für Ihr System.

Virtuelle Umgebung erstellen (optional)

Eine virtuelle Umgebung hält Abhängigkeiten isoliert. Erstellen Sie sie mit:

• python -m venv venv Aktivieren Sie die Umgebung:
• Unter Windows: venv\Scripts\activate
• Unter Linux/Mac: source venv/bin/activate Nach der Aktivierung erscheint der Umgebungsname in der Kommandozeile.

Bibliotheken installieren

Die benötigten Bibliotheken werden mit pip installiert. Führen Sie folgenden Befehl aus:

• pip install opencv-python numpy matplotlib Dies installiert:
• opencv-python: Für die Video- und Bildverarbeitung
• numpy: Für numerische Berechnungen
• matplotlib: Für Diagramme Stellen Sie sicher, dass die Installation ohne Fehler abläuft.

Code vorbereiten

Kopieren Sie den „VideoNoiseDetector“-Code in eine Datei, z. B. video_noise_detector.py. Speichern Sie diese in einem Verzeichnis Ihrer Wahl. Navigieren Sie in der Kommandozeile zu diesem Verzeichnis mit:

• cd /pfad/zu/ihrem/verzeichnis

OpenCV Haar-Cascade-Datei

Der Code nutzt die Datei haarcascade_frontalface_default.xml, die mit opencv-python geliefert wird. Kein zusätzlicher Download ist nötig, solange die Bibliothek korrekt installiert ist.

Programm starten

Führen Sie das Skript aus mit:

• python video_noise_detector.py Geben Sie den Pfad zu einer Videodatei ein, wenn Sie dazu aufgefordert werden. Das Programm analysiert das Video und speichert die Ergebnisse.

Betriebssystem-spezifische Hinweise

• Windows: Keine zusätzlichen Schritte nötig.
• Linux: Eventuell müssen Systempakete installiert werden, z. B. mit sudo apt-get install libopencv-dev.
• Mac: Installieren Sie ggf. Abhängigkeiten mit Homebrew: brew install libpng jpeg.

Fehlerbehebung

• Falls pip install opencv-python fehlschlägt, versuchen Sie pip install opencv-contrib-python.
• Bei Problemen mit dem Video überprüfen Sie den Dateipfad und das Format (z. B. MP4, AVI).
• Stellen Sie sicher, dass die Kommandozeile im richtigen Verzeichnis ist.

Testen der Installation

Bereiten Sie eine kurze Videodatei vor. Starten Sie das Skript und geben Sie den Pfad ein. Das Programm erstellt ein Analysevideo, zeigt Statistiken an und öffnet ein Diagramm. Bei Fehlern prüfen Sie die Konsolenausgabe.

Deinstallation (falls nötig)

Entfernen Sie die Bibliotheken mit:

• pip uninstall opencv-python numpy matplotlib Deaktivieren Sie die virtuelle Umgebung mit deactivate.