Gesichtserkennung und Face Tracking Modelle

from ultralytics import YOLO
import cv2

# Modell laden
model = YOLO('yolov8n-face.pt')

# Einzelbild verarbeiten
results = model('path/to/your/image.jpg')

# Videostream verarbeiten
cap = cv2.VideoCapture(0)
while True:
    ret, frame = cap.read()
    if not ret:
        break
    
    results = model(frame)
    annotated_frame = results[0].plot()
    cv2.imshow('Face Detection', annotated_frame)
    
    if cv2.waitKey(1) & 0xFF == ord('q'):
        break

cap.release()
cv2.destroyAllWindows()

import mediapipe as mp
import cv2

# MediaPipe Face Detection einmal initialisieren
mp_face_detection = mp.solutions.face_detection
mp_drawing = mp.solutions.drawing_utils

cap = cv2.VideoCapture(0)

# 'with' Operator außerhalb der Schleife für korrektes Ressourcen-Management
with mp_face_detection.FaceDetection(
    model_selection=0, min_detection_confidence=0.5) as face_detection:

    while cap.isOpened():
        success, image = cap.read()
        if not success:
            print("Ignoriere leeren Frame von der Kamera.")
            continue

        # Für bessere Performance optional das Bild als nicht bearbeitbar markieren
        # für Referenz-Übertragung.
        image.flags.writeable = False
        image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
        results = face_detection.process(image)

        # Face Detection Annotationen auf das Bild zeichnen.
        image.flags.writeable = True
        image = cv2.cvtColor(image, cv2.COLOR_RGB2BGR)
        if results.detections:
            for detection in results.detections:
                mp_drawing.draw_detection(image, detection)
        
        cv2.imshow('MediaPipe Face Detection', image)
        if cv2.waitKey(5) & 0xFF == 27:  # ESC key
            break

cap.release()
cv2.destroyAllWindows()

from retinaface import RetinaFace
import cv2
import numpy as np

def detect_faces_retinaface(image_path):
    # RetinaFace Detection
    faces = RetinaFace.detect_faces(image_path)
    
    if isinstance(faces, dict):
        image = cv2.imread(image_path)
        
        for key in faces.keys():
            face = faces[key]
            facial_area = face["facial_area"]
            
            # Begrenzungsrechteck zeichnen
            cv2.rectangle(image, 
                         (facial_area[0], facial_area[1]), 
                         (facial_area[2], facial_area[3]), 
                         (0, 255, 0), 2)
            
            # Konfidenz-Score hinzufügen
            confidence = face.get("score", 0)
            cv2.putText(image, f'{confidence:.2f}', 
                       (facial_area[0], facial_area[1]-10),
                       cv2.FONT_HERSHEY_SIMPLEX, 0.6, (0, 255, 0), 2)
        
        return image
    
    return None

# Verwendung
result_image = detect_faces_retinaface('path/to/image.jpg')
if result_image is not None:
    cv2.imshow('RetinaFace Detection', result_image)
    cv2.waitKey(0)
    cv2.destroyAllWindows()

import cv2
from yolox.tracker.byte_tracker import BYTETracker
from ultralytics import YOLO

class VideoTracker:
    def __init__(self):
        self.model = YOLO('yolov8n-face.pt')
        self.tracker = BYTETracker(frame_rate=30)
    
    def track_video(self, video_path):
        cap = cv2.VideoCapture(video_path)
        frame_id = 0
        
        while True:
            ret, frame = cap.read()
            if not ret:
                break
            
            # Detection
            results = self.model(frame)
            
            # In Format für Tracking konvertieren
            detections = []
            if len(results[0].boxes) > 0:
                boxes = results[0].boxes.xyxy.cpu().numpy()
                scores = results[0].boxes.conf.cpu().numpy()
                
                for box, score in zip(boxes, scores):
                    detections.append([*box, score])
            
            # Tracker aktualisieren
            tracks = self.tracker.update(
                np.array(detections), 
                frame.shape[:2], 
                frame.shape[:2]
            )
            
            # Tracks zeichnen
            for track in tracks:
                x1, y1, x2, y2, track_id = track[:5]
                cv2.rectangle(frame, (int(x1), int(y1)), (int(x2), int(y2)), (0, 255, 0), 2)
                cv2.putText(frame, f'ID: {int(track_id)}', 
                           (int(x1), int(y1)-10),
                           cv2.FONT_HERSHEY_SIMPLEX, 0.6, (0, 255, 0), 2)
            
            cv2.imshow('Face Tracking', frame)
            if cv2.waitKey(1) & 0xFF == ord('q'):
                break
            
            frame_id += 1
        
        cap.release()
        cv2.destroyAllWindows()

# Verwendung
tracker = VideoTracker()
tracker.track_video('path/to/video.mp4')

# Face Detector Implementierung für mobile Geräte.
import mediapipe as mp
import cv2
import numpy as np
import time

class MobileFaceDetector:
    """
    Klasse für Face Detection im Videostream, optimiert für
    Performance auf mobilen Geräten.

    Beinhaltet Frame-Skipping für Ziel-FPS und glatte
    Rahmen-Darstellung zur Vermeidung von "Flimmern".
    """
    def __init__(self, model_selection=0, min_detection_confidence=0.7):
        """
        Initialisiert den Face Detector.

        Args:
            model_selection (int): Modellwahl. 0 für Nahbereich (bis 2 Meter),
                                   1 für Fernbereich (bis 5 Meter).
            min_detection_confidence (float): Minimaler Konfidenzschwellwert für Detection.
        """
        # --- MediaPipe Face Detection Initialisierung ---
        # Erstelle Instanz mit gegebenen Parametern.
        self.face_detection = mp.solutions.face_detection.FaceDetection(
            model_selection=model_selection,
            min_detection_confidence=min_detection_confidence,
        )
        
        # --- Variablen für Darstellung und FPS ---
        # Speichere letzte erfolgreiche Detections, um sie auf übersprungenen Frames zu zeichnen.
        self.last_results = None
        # Speichere ursprüngliche Frame-Größe für korrekte Skalierung.
        self.original_width = 0
        self.original_height = 0

    def _draw_detections(self, frame, detections):
        """
        Hilfsfunktion zum Zeichnen von Rahmen auf dem Frame.
        
        Args:
            frame (np.ndarray): Frame, auf dem gezeichnet werden soll.
            detections: Detection-Ergebnisse von MediaPipe.
        """
        if detections:
            for detection in detections:
                # Relative Rahmen-Koordinaten erhalten (von 0.0 bis 1.0).
                bboxC = detection.location_data.relative_bounding_box
                
                # Koordinaten zurück zur ursprünglichen Frame-Größe skalieren.
                x = int(bboxC.xmin * self.original_width)
                y = int(bboxC.ymin * self.original_height)
                width = int(bboxC.width * self.original_width)
                height = int(bboxC.height * self.original_height)
                
                # Rechteck auf originalem Frame zeichnen.
                cv2.rectangle(frame, (x, y), (x + width, y + height), (0, 255, 0), 2)
        return frame

    def process_frame(self, frame, target_width=320):
        """
        Verarbeitet einen Frame aus dem Videostream.

        Args:
            frame (np.ndarray): Eingabe-Frame im BGR-Format.
            target_width (int): Zielbreite für Verarbeitung. Frame wird
                                proportional auf diese Breite verkleinert.

        Returns:
            np.ndarray: Frame mit gezeichneten Rahmen.
        """
        self.original_height, self.original_width = frame.shape[:2]

        # --- Optimierung 1: Auflösungsreduzierung ---
        # Seitenverhältnis beibehalten.
        scale = target_width / self.original_width
        small_frame = cv2.resize(frame, (0, 0), fx=scale, fy=scale, interpolation=cv2.INTER_AREA)

        # --- Optimierung 2: Farbkonvertierung und Performance-Steigerung ---
        # MediaPipe benötigt RGB. Konvertiere einmal.
        rgb_small_frame = cv2.cvtColor(small_frame, cv2.COLOR_BGR2RGB)
        # Markiere Frame als "nur lesen" zur Beschleunigung.
        rgb_small_frame.flags.writeable = False

        # --- Face Detection ---
        results = self.face_detection.process(rgb_small_frame)
        
        # Stelle Flag wieder her, falls weitere Arbeit mit Frame nötig.
        rgb_small_frame.flags.writeable = True

        # --- Darstellung ---
        # Wenn Detection erfolgreich war, speichere Ergebnisse.
        if results.detections:
            self.last_results = results.detections
        
        # Zeichne Rahmen auf ursprünglichem Frame. Wenn im aktuellen Frame keine Gesichter
        # gefunden wurden, aber sie in vorherigen waren, nutze alte Daten für Glätte.
        processed_frame = self._draw_detections(frame, self.last_results)
        
        return processed_frame
        
    def close(self):
        """Gibt MediaPipe-Ressourcen frei."""
        self.face_detection.close()

# --- Beispielverwendung mit Webcam ---
if __name__ == '__main__':
    # Detector initialisieren
    detector = MobileFaceDetector(min_detection_confidence=0.5)
    
    # Video von Webcam erfassen (0 - meist integrierte Kamera)
    cap = cv2.VideoCapture(0)
    
    if not cap.isOpened():
        print("Fehler: Konnte Webcam nicht öffnen.")
        exit()

    # Variablen für FPS-Berechnung
    prev_frame_time = 0
    new_frame_time = 0

    try:
        while True:
            # Frame von Kamera lesen
            success, frame = cap.read()
            if not success:
                print("Konnte Frame nicht erhalten. Beende.")
                break

            # Frame für "Spiegel"-Effekt umdrehen
            frame = cv2.flip(frame, 1)

            # --- Verarbeitung für Ziel-FPS überspringen ---
            # Das ist weniger wichtig mit neuer Darstellungslogik, spart aber trotzdem Ressourcen
            # Hier kannst du deine Frame-Skip-Logik implementieren, falls nötig
            
            # Frame verarbeiten
            processed_frame = detector.process_frame(frame)

            # --- FPS-Berechnung und -Anzeige ---
            new_frame_time = time.time()
            fps = 1 / (new_frame_time - prev_frame_time)
            prev_frame_time = new_frame_time
            cv2.putText(processed_frame, f'FPS: {int(fps)}', (10, 30), cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 255, 0), 2)
            
            # Ergebnis anzeigen
            cv2.imshow('Mobile Face Detection', processed_frame)

            # Beenden mit 'q'-Taste
            if cv2.waitKey(1) & 0xFF == ord('q'):
                break
    finally:
        # Ressourcen freigeben
        print("Gebe Ressourcen frei...")
        cap.release()
        detector.close()
        cv2.destroyAllWindows()

# Sicherheitssystem mit Tracking, Verifikation,
# optimierter Erkennung und Visualisierung.
import cv2
import numpy as np
import time
import os
import pickle
from typing import Dict, List, Any, Optional, Tuple

# --- Angenommen, diese Bibliotheken sind installiert ---
# pip install opencv-python numpy
# pip install insightface
# pip install retinaface-pytorch deep-sort-realtime
#
# Wichtig: InsightFace benötigt onnxruntime-gpu. DeepSort hat auch seine Abhängigkeiten.
# Installation kann zusätzliche Schritte erfordern, einschließlich Modell-Downloads.

from retinaface import RetinaFace
from deep_sort_realtime.deepsort_tracker import DeepSort
from insightface.app import FaceAnalysis

class AdvancedSecuritySystem:
    """
    Umfassendes Sicherheitssystem, das Face Detection, Tracking und
    Gesichtserkennung mit Echtzeit-Optimierungen vereint.
    """

    def __init__(self, db_path: str, detection_thresh: float = 0.9, recognition_thresh: float = 0.5):
        """
        Initialisierung aller System-Komponenten.

        Args:
            db_path (str): Pfad zur Gesichtsdatenbank-Datei (.pkl).
            detection_thresh (float): Konfidenzschwelle für Face Detector.
            recognition_thresh (float): Ähnlichkeitsschwelle für Gesichtserkennung.
        """
        print("Initialisiere Sicherheitssystem...")

        # --- Face Detector (RetinaFace) ---
        # RetinaFace eignet sich gut für "schwierige" Gesichter.
        # Für CPU kann 'mobilenet' verwendet werden, für GPU - 'resnet50'.
        self.detector = RetinaFace(gpu_id=0) # -1 für CPU angeben
        print("Face Detector (RetinaFace) initialisiert.")

        # --- Tracker (DeepSort) ---
        # max_age: wie viele Frames ein Track ohne Detection existieren kann.
        # n_init: wie oft ein Objekt detektiert werden muss für Track-Start.
        self.tracker = DeepSort(max_age=30, n_init=3)
        print("Tracker (DeepSort) initialisiert.")

        # --- Face Recognition (InsightFace) ---
        # CUDA für maximale Performance nutzen.
        self.recognizer = FaceAnalysis(name='buffalo_l', providers=['CUDAExecutionProvider'])
        self.recognizer.prepare(ctx_id=0) # ctx_id=0 für GPU, -1 für CPU
        print("Face Recognition (InsightFace) initialisiert.")
        
        # --- Parameter und Datenbank ---
        self.detection_thresh = detection_thresh
        self.recognition_thresh = recognition_thresh
        self.face_db = self._load_face_database(db_path)
        
        # Dictionary für bereits erkannte Identitäten nach track_id
        # {track_id: {"identity": "Name", "verified": True/False}}
        self.tracked_identities: Dict[str, Dict[str, Any]] = {}

    def _load_face_database(self, db_path: str) -> Optional[Dict[str, np.ndarray]]:
        """Lädt vorab erstellte Embedding-Datenbank."""
        if not os.path.exists(db_path):
            print(f"Fehler: Datenbankdatei nicht gefunden unter: {db_path}")
            print("Bitte erstelle zuerst eine Datenbank mit create_database_from_folder().")
            return None
        with open(db_path, 'rb') as f:
            db = pickle.load(f)
            print(f"Gesichtsdatenbank erfolgreich geladen. {len(db)} Identitäten gefunden.")
            return db

    def _extract_embedding(self, frame: np.ndarray, bbox: np.ndarray) -> Optional[np.ndarray]:
        """Extrahiert Embedding (Feature-Vektor) aus Gesichtsbereich."""
        # Gesicht sicher ausschneiden, Koordinaten an Frame-Grenzen beschneiden
        h, w = frame.shape[:2]
        x1, y1, x2, y2 = np.maximum(0, bbox).astype(int)
        x2, y2 = min(x2, w), min(y2, h)
        
        face_img = frame[y1:y2, x1:x2]
        if face_img.size == 0:
            return None
            
        # InsightFace für Embedding verwenden
        faces = self.recognizer.get(face_img)
        return faces[0].embedding if faces else None

    def _find_match(self, embedding: np.ndarray) -> Tuple[str, float]:
        """Findet ähnlichstes Gesicht in der Datenbank."""
        if embedding is None or self.face_db is None:
            return "Unknown", 0.0
            
        best_match = "Unknown"
        best_score = 0.0
        
        # Kosinus-Ähnlichkeit verwenden (Skalarprodukt normalisierter Vektoren)
        for name, db_embed in self.face_db.items():
            score = np.dot(embedding, db_embed) / (np.linalg.norm(embedding) * np.linalg.norm(db_embed))
            if score > self.recognition_thresh and score > best_score:
                best_score = score
                best_match = name
                
        return best_match, best_score

    def process_frame(self, frame: np.ndarray) -> np.ndarray:
        """
        Vollständiger Verarbeitungszyklus eines Frames: Detection, Tracking, Recognition.

        Returns:
            np.ndarray: Frame mit gezeichneten Informationen (Rahmen, ID, Namen).
        """
        if self.face_db is None:
            cv2.putText(frame, "Face DB not loaded!", (20, 40), cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 0, 255), 2)
            return frame
            
        # --- 1. Detection ---
        # RetinaFace gibt Dictionary zurück, das konvertiert werden muss
        detections_raw = self.detector.detect(frame, threshold=self.detection_thresh)
        
        # Konvertierung in DeepSort-verständliches Format: [[x1, y1, x2, y2], confidence]
        deepsort_detections = []
        for face_data in detections_raw:
            x1, y1, x2, y2, conf = face_data
            deepsort_detections.append(([x1, y1, x2, y2], conf, "face"))

        # --- 2. Tracking ---
        tracks = self.tracker.update_tracks(deepsort_detections, frame=frame)
        
        # --- 3. Recognition und Visualisierung ---
        for track in tracks:
            if not track.is_confirmed():
                continue
            
            track_id = track.track_id
            bbox = track.to_tlbr() # (x1, y1, x2, y2)
            
            identity_info = self.tracked_identities.get(track_id)
            
            # OPTIMIERUNG: Nur neue Tracks erkennen
            if identity_info is None:
                embedding = self._extract_embedding(frame, bbox)
                name, score = self._find_match(embedding)
                self.tracked_identities[track_id] = {"identity": name, "score": score}
                identity_info = self.tracked_identities[track_id]

            # --- Visualisierung ---
            name = identity_info.get("identity", "Unknown")
            score = identity_info.get("score", 0.0)
            
            color = (0, 255, 0) if name != "Unknown" else (0, 0, 255)
            # Rahmen zeichnen
            cv2.rectangle(frame, (int(bbox[0]), int(bbox[1])), (int(bbox[2]), int(bbox[3])), color, 2)
            # Text für Beschriftung bilden
            label = f"ID: {track_id} | {name} ({score:.2f})"
            # Beschriftung zeichnen
            cv2.putText(frame, label, (int(bbox[0]), int(bbox[1]) - 10), cv2.FONT_HERSHEY_SIMPLEX, 0.7, color, 2)
            
        return frame

    def create_database_from_folder(self, folder_path: str, output_db_path: str):
        """
        Erstellt Embedding-Datenbank aus Ordner mit Bildern.
        Ordnerstruktur:
        - folder_path/
          - person_1/
            - image1.jpg
            - image2.png
          - person_2/
            - photo.jpg
        """
        face_db = {}
        print(f"Erstelle Datenbank aus Ordner: {folder_path}")
        for person_name in os.listdir(folder_path):
            person_folder = os.path.join(folder_path, person_name)
            if not os.path.isdir(person_folder):
                continue
            
            embeddings = []
            for image_name in os.listdir(person_folder):
                image_path = os.path.join(person_folder, image_name)
                img = cv2.imread(image_path)
                if img is None:
                    continue
                
                # Embedding für erstes gefundenes Gesicht im Foto erhalten
                faces = self.recognizer.get(img)
                if faces:
                    embeddings.append(faces[0].embedding)
            
            if embeddings:
                # Embeddings für größere Stabilität mitteln
                face_db[person_name] = np.mean(embeddings, axis=0)
                print(f"-> Gesicht gefunden und verarbeitet: {person_name}")

        # Datenbank in Datei speichern
        with open(output_db_path, 'wb') as f:
            pickle.dump(face_db, f)
        print(f"Datenbank erfolgreich erstellt und gespeichert unter: {output_db_path}")

# --- Beispielverwendung ---
if __name__ == '__main__':
    DB_FILE = "face_db.pkl"
    DB_SOURCE_FOLDER = "face_images" # Ordner mit Fotos für DB-Erstellung
    
    # --- Schritt 1: Datenbank erstellen (einmalig ausführen) ---
    # Für diesen Schritt muss Ordner face_images erstellt werden mit Unterordnern
    # mit Personennamen, die deren Fotos enthalten.
    if not os.path.exists(DB_FILE):
        print("Datenbank nicht gefunden. Starte Erstellungsprozess...")
        # Temporären Ordner für Beispiel erstellen, falls nicht vorhanden
        if not os.path.exists(DB_SOURCE_FOLDER):
            os.makedirs(os.path.join(DB_SOURCE_FOLDER, "person_example"))
            print(f"Beispielordner erstellt: {DB_SOURCE_FOLDER}/person_example")
            print("Bitte lege .jpg-Dateien mit Gesichtern dort ab und starte das Skript neu.")
            exit()
            
        # System nur für DB-Erstellung initialisieren
        temp_system = AdvancedSecuritySystem(db_path=DB_FILE)
        temp_system.create_database_from_folder(DB_SOURCE_FOLDER, DB_FILE)
        print("-" * 30)

    # --- Schritt 2: System im Videostream starten ---
    system = AdvancedSecuritySystem(db_path=DB_FILE)
    cap = cv2.VideoCapture(0) # 0 für Webcam oder Pfad zu Videodatei

    if not cap.isOpened():
        print("Fehler: Konnte Videostream nicht öffnen.")
        exit()

    prev_time = 0
    try:
        while True:
            success, frame = cap.read()
            if not success:
                break
            
            # Frame-Verarbeitung
            processed_frame = system.process_frame(frame)

            # FPS-Berechnung und -Anzeige
            curr_time = time.time()
            fps = 1 / (curr_time - prev_time)
            prev_time = curr_time
            cv2.putText(processed_frame, f"FPS: {int(fps)}", (20, 80), cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 255, 0), 2)
            
            cv2.imshow("Advanced Security System", processed_frame)
            
            if cv2.waitKey(1) & 0xFF == ord('q'):
                break
    finally:
        print("Beende und gebe Ressourcen frei.")
        cap.release()
        cv2.destroyAllWindows()

# Face Detection und Tracking Implementierung für Edge-Geräte
# mit TensorFlow Lite.

import cv2
import numpy as np
import time
import argparse
from typing import List, Dict, Any, Tuple, Optional

# Für dieses Skript wird tflite_runtime benötigt.
# Installation: pip install tflite-runtime
try:
    from tflite_runtime.interpreter import Interpreter
except ImportError:
    print("Fehler: tflite_runtime nicht gefunden. Bitte installiere es:")
    print("pip install tflite-runtime")
    exit()

class EdgeFacePipeline:
    """
    Klasse für Face Detection und Tracking auf Edge-Geräten mit TFLite.
    Beinhaltet Hardware-Optimierungen und leichtgewichtigen IOU-Tracker.
    """
    def __init__(self, model_path: str, device: str = 'cpu', conf_thresh: float = 0.7):
        """
        Pipeline-Initialisierung.

        Args:
            model_path (str): Pfad zur .tflite Modelldatei.
            device (str): Ausführungsgerät ('cpu' oder 'npu').
            conf_thresh (float): Konfidenzschwelle für Face Detection.
        """
        print(f"Lade TFLite-Modell von: {model_path}")
        self.interpreter = Interpreter(model_path=model_path)
        self.interpreter.allocate_tensors()

        self.input_details = self.interpreter.get_input_details()
        self.output_details = self.interpreter.get_output_details()
        
        # Wichtig: exakte Größen erhalten, die das Modell benötigt
        self.input_height = self.input_details[0]['shape'][1]
        self.input_width = self.input_details[0]['shape'][2]

        self.conf_thresh = conf_thresh
        self.tracked_faces: List[Dict[str, Any]] = []
        self.next_track_id = 0
        self.iou_thresh = 0.4 # IOU-Schwelle für Tracking

        self._configure_device(device)
        print(f"Pipeline für Gerät initialisiert: {device}")

    def _configure_device(self, device: str):
        """Wendet hardware-spezifische Optimierungen an."""
        cv2.setUseOptimized(True)
        # Einstellungen für Neuroprozessor (NPU)
        if device == 'npu':
            # Hier könnten NPU-spezifische Delegates sein, z.B. 'libedgetpu.so.1'
            # self.interpreter = Interpreter(model_path=self.model_path,
            #                                experimental_delegates=[load_delegate('libedgetpu.so.1')])
            self.interpreter.set_num_threads(1)
            print("NPU-Optimierungen angewandt (vereinfachte Konfiguration).")
        # CPU-Optimierungen
        else:
            self.interpreter.set_num_threads(4)
            print("CPU-Optimierungen angewandt (4 Threads).")

    def _preprocess(self, frame: np.ndarray) -> np.ndarray:
        """
        Frame-Vorbereitung für neuronales Netz: Größenänderung und Normalisierung.
        """
        # Resize auf exakte Modell-Eingabegröße ---
        resized_frame = cv2.resize(frame, (self.input_width, self.input_height))
        
        # In RGB konvertieren, falls Modell das benötigt
        rgb_frame = cv2.cvtColor(resized_frame, cv2.COLOR_BGR2RGB)
        
        # Normalisierung und Batch-Dimension hinzufügen
        # Viele TFLite-Modelle erwarten float32 im Bereich [-1, 1] oder [0, 1]
        # oder uint8 [0, 255]. Prüfe Dokumentation deines Modells.
        # Hier nehmen wir float32 [0, 1] an.
        input_data = np.expand_dims(rgb_frame, axis=0).astype(np.float32) / 255.0
        return input_data

    def process_frame(self, frame: np.ndarray) -> List[Dict[str, Any]]:
        """
        Vollständiger Verarbeitungszyklus: Detection und Tracking.

        Args:
            frame (np.ndarray): Eingabe-Frame im BGR-Format.

        Returns:
            List[Dict[str, Any]]: Liste verfolgter Gesichter mit ID und Koordinaten.
        """
        original_h, original_w = frame.shape[:2]
        
        # 1. Frame-Vorverarbeitung
        input_data = self._preprocess(frame)
        
        # 2. Modell-Inferenz
        self.interpreter.set_tensor(self.input_details[0]['index'], input_data)
        self.interpreter.invoke()
        
        # 3. Ergebnisse erhalten und nachverarbeiten
        # Ausgabeformat kann für verschiedene Modelle unterschiedlich sein.
        # Nehmen an, dass Modell [boxes, scores] zurückgibt.
        boxes = self.interpreter.get_tensor(self.output_details[0]['index'])[0]
        scores = self.interpreter.get_tensor(self.output_details[1]['index'])[0]

        current_detections = []
        for i, score in enumerate(scores):
            if score > self.conf_thresh:
                # Koordinaten werden normalisiert zurückgegeben [ymin, xmin, ymax, xmax]
                ymin, xmin, ymax, xmax = boxes[i]
                
                # Koordinaten auf ursprüngliche Frame-Größe skalieren
                abs_xmin = int(xmin * original_w)
                abs_ymin = int(ymin * original_h)
                abs_xmax = int(xmax * original_w)
                abs_ymax = int(ymax * original_h)
                
                current_detections.append({
                    'bbox': (abs_xmin, abs_ymin, abs_xmax, abs_ymax),
                    'score': float(score)
                })
        
        # 4. Tracker-Update
        self._update_tracker(current_detections)
        return self.tracked_faces

    def _update_tracker(self, new_detections: List[Dict[str, Any]]):
        """Aktualisiert Tracks basierend auf neuen Detections mit IOU."""
        if not self.tracked_faces:
            # Wenn keine Tracks vorhanden, aus neuen Detections initialisieren
            for det in new_detections:
                det['track_id'] = self.next_track_id
                det['age'] = 0 # Track-"Alter"-Zähler
                self.tracked_faces.append(det)
                self.next_track_id += 1
            return

        matched_indices = set()
        
        # Versuche neue Detections mit existierenden Tracks zu verknüpfen
        for i, track in enumerate(self.tracked_faces):
            best_match_iou = 0
            best_match_idx = -1
            for j, det in enumerate(new_detections):
                if j in matched_indices:
                    continue
                iou = self._calculate_iou(track['bbox'], det['bbox'])
                if iou > self.iou_thresh and iou > best_match_iou:
                    best_match_iou = iou
                    best_match_idx = j
            
            if best_match_idx != -1:
                # Track aktualisieren
                track['bbox'] = new_detections[best_match_idx]['bbox']
                track['age'] = 0 # Alter zurücksetzen, da Track gefunden
                matched_indices.add(best_match_idx)
            else:
                # Alter erhöhen, wenn Track nicht gefunden
                track['age'] += 1

        # Neue Tracks für nicht verknüpfte Detections hinzufügen
        for j, det in enumerate(new_detections):
            if j not in matched_indices:
                det['track_id'] = self.next_track_id
                det['age'] = 0
                self.tracked_faces.append(det)
                self.next_track_id += 1
        
        # Alte Tracks entfernen, die eine Zeit lang nicht gesehen wurden
        self.tracked_faces = [t for t in self.tracked_faces if t['age'] < 15]

    @staticmethod
    def _calculate_iou(box1: Tuple, box2: Tuple) -> float:
        """Berechnet Intersection over Union (IOU) für zwei Rahmen."""
        x1, y1, x2, y2 = box1
        x3, y3, x4, y4 = box2
        
        xi1, yi1 = max(x1, x3), max(y1, y3)
        xi2, yi2 = min(x2, x4), min(y2, y4)
        
        inter_area = max(0, xi2 - xi1) * max(0, yi2 - yi1)
        box1_area = (x2 - x1) * (y2 - y1)
        box2_area = (x4 - x3) * (y4 - y3)
        
        union_area = box1_area + box2_area - inter_area
        return inter_area / union_area if union_area > 0 else 0.0

def draw_results(frame: np.ndarray, faces: List[Dict[str, Any]]):
    """Zeichnet Ergebnisse auf Frame."""
    for face in faces:
        # Koordinaten für Darstellung verwenden
        xmin, ymin, xmax, ymax = face['bbox']
        track_id = face['track_id']
        
        cv2.rectangle(frame, (xmin, ymin), (xmax, ymax), (0, 255, 0), 2)
        label = f"ID: {track_id}"
        cv2.putText(frame, label, (xmin, ymin - 10),
                    cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0, 255, 0), 2)

# Beispielverwendung
if __name__ == "__main__":
    parser = argparse.ArgumentParser(description="Face Detection auf Edge-Geräten")
    parser.add_argument("--model", type=str, required=True, help="Pfad zur .tflite Modelldatei.")
    parser.add_argument("--device", type=str, default='cpu', choices=['cpu', 'npu'], help="Gerät für Inferenz.")
    parser.add_argument("--video", type=str, help="Pfad zu Videodatei. Falls nicht angegeben, nutze Webcam.")
    args = parser.parse_args()

    pipeline = EdgeFacePipeline(model_path=args.model, device=args.device)
    
    cap = cv2.VideoCapture(args.video if args.video else 0)
    if not cap.isOpened():
        print(f"Fehler: Konnte Videoquelle nicht öffnen.")
        exit()
        
    prev_time = 0
    try:
        while True:
            ret, frame = cap.read()
            if not ret:
                break
                
            # Frame-Verarbeitung
            tracked_faces = pipeline.process_frame(frame)
            
            # Ergebnisse visualisieren
            draw_results(frame, tracked_faces)
            
            # FPS anzeigen
            curr_time = time.time()
            fps = 1 / (curr_time - prev_time)
            prev_time = curr_time
            cv2.putText(frame, f"FPS: {int(fps)}", (10, 30),
                        cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 0, 255), 2)
            
            cv2.imshow('Edge Face Detection', frame)
            
            if cv2.waitKey(1) & 0xFF == ord('q'):
                break
    finally:
        print("Beende und gebe Ressourcen frei.")
        cap.release()
        cv2.destroyAllWindows()

# Virtuelle Umgebung erstellen
python -m venv face_detection_env
source face_detection_env/bin/activate

# Basis-Abhängigkeiten
pip install opencv-python mediapipe ultralytics

# Für erweiterte Modelle
pip install insightface retinaface-pytorch deepface

# Für Tracking
pip install yolox filterpy scikit-image

import gc
import torch

def optimize_gpu_memory():
    """GPU-Speicher nach Verarbeitung bereinigen"""
    if torch.cuda.is_available():
        torch.cuda.empty_cache()
        gc.collect()

def batch_processing(image_list, model, batch_size=4):
    """Batch-Verarbeitung für Durchsatz-Optimierung"""
    results = []
    
    for i in range(0, len(image_list), batch_size):
        batch = image_list[i:i+batch_size]
        batch_results = model(batch)
        results.extend(batch_results)
        
        # Speicher nach jedem Batch bereinigen
        optimize_gpu_memory()
    
    return results

import threading
from queue import Queue
import time

class ThreadedVideoProcessor:
    def __init__(self, model):
        self.model = model
        self.frame_queue = Queue(maxsize=10)
        self.result_queue = Queue(maxsize=10)
        self.processing = True
        
    def frame_reader(self, video_source):
        cap = cv2.VideoCapture(video_source)
        while self.processing:
            ret, frame = cap.read()
            if not ret:
                break
            
            if not self.frame_queue.full():
                self.frame_queue.put(frame)
        cap.release()
    
    def frame_processor(self):
        while self.processing:
            if not self.frame_queue.empty():
                frame = self.frame_queue.get()
                result = self.model(frame)
                
                if not self.result_queue.full():
                    self.result_queue.put((frame, result))

# Beispiel: Bias-Testing Framework
def evaluate_model_bias(model, test_datasets):
    """
    Bewertung der Modell-Performance nach demografischen Gruppen
    """
    results = {}
    
    for group_name, dataset in test_datasets.items():
        detections = []
        for image_path in dataset['images']:
            result = model(image_path)
            detections.append(result)
        
        # Metriken für diese demografische Gruppe berechnen
        accuracy = calculate_accuracy(detections, dataset['ground_truth'])
        results[group_name] = {
            'accuracy': accuracy,
            'sample_size': len(dataset['images'])
        }
    
    return results

# Beispielverwendung
demographic_results = evaluate_model_bias(model, {
    'young': young_adult_dataset,
    'elderly': elderly_dataset,
    'diverse': diverse_dataset
})

class ConsentAwareFaceTracker:
    def __init__(self):
        self.user_consent = self.check_user_consent()
        self.tracking_enabled = False
        
    def check_user_consent(self):
        # Gespeicherte Nutzer-Präferenzen prüfen
        # Einverständnis-Status und Zeitstempel zurückgeben
        pass
    
    def request_consent(self):
        """
        Klaren Einverständnis-Dialog dem Nutzer präsentieren
        """
        consent_text = """
        Diese App nutzt Face Detection für:
        - Verbesserung deiner AR-Filter-Erfahrung
        - Automatischen Kamera-Fokus auf Gesichter
        
        Deine Gesichtsdaten:
        - Werden vollständig auf deinem Gerät verarbeitet
        - Niemals gespeichert oder übertragen
        - Können jederzeit in den Einstellungen deaktiviert werden
        
        Stimmst du der Face Detection zu? [Ja/Nein]
        """
        return self.present_consent_dialog(consent_text)
    
    def process_with_consent(self, frame):
        if not self.user_consent['granted']:
            return frame  # Unverarbeiteten Frame zurückgeben
        
        if self.consent_expired():
            self.user_consent = self.request_consent()
        
        return self.detect_faces(frame) if self.user_consent['granted'] else frame