controlnet_module.py

import torch
from diffusers import StableDiffusionControlNetPipeline, ControlNetModel
from controlnet_aux import OpenposeDetector
from PIL import Image, ImageFilter, ImageEnhance  # NEU: ImageEnhance für Kontrast
import random
import cv2
import numpy as np
import gradio as gr
import torch.nn.functional as F
from transformers import Sam2Model, Sam2Processor
from scipy import ndimage
from skimage import measure, morphology

# === CONTROLNET FORTSCHRITTS-CALLBACK (Für Gradio-UI) ===
class ControlNetProgressCallback:
    def __init__(self, progress, total_steps):
        self.progress = progress
        self.total_steps = total_steps
        self.current_step = 0

    def __call__(self, pipe, step_index, timestep, callback_kwargs):
        self.current_step = step_index + 1
        progress_percentage = self.current_step / self.total_steps

        if self.progress is not None:
            self.progress(progress_percentage, desc=f"ControlNet: Schritt {self.current_step}/{self.total_steps}")

        print(f"ControlNet Fortschritt: {self.current_step}/{self.total_steps} ({progress_percentage:.1%})")
        return callback_kwargs


class ControlNetProcessor:
    def __init__(self, device="cuda", torch_dtype=torch.float32):
        self.device = device
        self.torch_dtype = torch_dtype
        self.pose_detector = None
        self.midas_model = None
        self.midas_transform = None
        self.sam_processor = None
        self.sam_model = None
        self.sam_initialized = False

    def _lazy_load_sam(self):
        """Lazy Loading von SAM 2 über 🤗 Transformers API"""
        if self.sam_initialized:
            return True

        try:
            print("#" * 80)
            print("# 🔄 LADE SAM 2 (Segment Anything Model 2)")
            print("#" * 80)
            model_id = "facebook/sam2-hiera-tiny"
            
            print(f"📥 Modell-ID: {model_id}")
            print(f"📥 Lade Processor...")
            self.sam_processor = Sam2Processor.from_pretrained(model_id)
            print(f"📥 Lade Modell...")
            self.sam_model = Sam2Model.from_pretrained(model_id, torch_dtype=torch.float32).to(self.device)
            self.sam_model.eval()
            
            self.sam_initialized = True
            print("✅ SAM 2 erfolgreich geladen (via Transformers)")
            return True

        except Exception as e:
            print(f"❌ FEHLER beim Laden von SAM 2: {str(e)[:200]}")
            self.sam_initialized = True
            return False

    def _validate_bbox(self, image, bbox_coords):
        """Validiert und korrigiert BBox-Koordinaten"""
        width, height = image.size

        if isinstance(bbox_coords, (list, tuple)) and len(bbox_coords) == 4:
            x1, y1, x2, y2 = bbox_coords
        else:
            x1, y1, x2, y2 = bbox_coords

        x1, x2 = min(x1, x2), max(x1, x2)
        y1, y2 = min(y1, y2), max(y1, y2)

        x1 = max(0, min(x1, width - 1))
        y1 = max(0, min(y1, height - 1))
        x2 = max(0, min(x2, width - 1))
        y2 = max(0, min(y2, height - 1))

        if x2 - x1 < 10 or y2 - y1 < 10:
            size = min(width, height) * 0.3
            x1 = max(0, width/2 - size/2)
            y1 = max(0, height/2 - size/2)
            x2 = min(width, width/2 + size/2)
            y2 = min(height, height/2 + size/2)

        return int(x1), int(y1), int(x2), int(y2)

    def _smooth_mask(self, mask_array, blur_radius=3):
        """Glättet die Maske für bessere Übergänge"""
        try:
            if blur_radius > 0:
                mask_array = cv2.medianBlur(mask_array, blur_radius*2+1)
            return mask_array
        except Exception as e:
            print(f"⚠️ Fehler beim Glätten der Maske: {e}")
            return mask_array

    def create_sam_mask(self, image, bbox_coords, mode):
        """
        ERWEITERTE Funktion: Erstellt präzise Maske mit SAM 2
        Korrigierte Version für face_only_change mit einzelner BBox
        """
        try:
            print("#" * 80)
            print("# 🎯 STARTE SAM 2 SEGMENTIERUNG")
            print("#" * 80)
            print(f"📐 Eingabebild-Größe: {image.size}")
            print(f"🎛️  Ausgewählter Modus: {mode}")
            
            # Variablen für alle Modi initialisieren
            crop_size = None
            crop_x1 = crop_y1 = crop_x2 = crop_y2 = None
            original_image = image
            best_score = 0.0
            
            # 1. SAM2 laden
            if not self.sam_initialized:
                print("📥 SAM 2 ist noch nicht geladen, starte Lazy Loading...")
                self._lazy_load_sam()

            if self.sam_model is None or self.sam_processor is None:
                print("⚠️ SAM 2 Model nicht verfügbar, verwende Fallback")
                return self._create_rectangular_mask(image, bbox_coords, mode)
            else:
                print("✅ SAM 2 Modell ist geladen und bereit")

            # 2. Validiere BBox
            x1, y1, x2, y2 = self._validate_bbox(image, bbox_coords)
            original_bbox = (x1, y1, x2, y2)
            original_bbox_size = (x2 - x1, y2 - y1)
            print(f"📏 Original-BBox Größe: {original_bbox_size[0]} × {original_bbox_size[1]} px")
            
            # ============================================================
            # SPEZIALBEHANDLUNG NUR FÜR face_only_change
            # ============================================================
            if mode == "face_only_change":
                print("-" * 60)
                print("👤 SPEZIALMODUS: NUR GESICHT - ROBUSTER WORKFLOW")
                print("-" * 60)
                
                # ============================================================
                # SCHRITT 1: Originalbild sichern
                # ============================================================
                original_image = image
                print(f"💾 Originalbild gesichert: {original_image.size}")
                
                # ============================================================
                # SCHRITT 2: Crop = BBox × 2.5 (ERHÖHT für mehr Kontext)
                # ============================================================
                print("✂️ SCHRITT 2: ERSTELLE QUADRATISCHEN AUSSCHNITT (BBox × 2.5)")
                
                # BBox-Zentrum berechnen
                bbox_center_x = (x1 + x2) // 2
                bbox_center_y = (y1 + y2) // 2
                print(f"   📍 BBox-Zentrum: ({bbox_center_x}, {bbox_center_y})")
                
                # Größte Dimension der BBox finden
                bbox_width = x2 - x1
                bbox_height = y2 - y1
                bbox_max_dim = max(bbox_width, bbox_height)
                print(f"   📏 BBox Dimensionen: {bbox_width} × {bbox_height} px")
                print(f"   📐 Maximale BBox-Dimension: {bbox_max_dim} px")
                
                # Crop-Größe berechnen (BBox × 2.5)
                crop_size = int(bbox_max_dim * 2.5)
                print(f"   🎯 Ziel-Crop-Größe: {crop_size} × {crop_size} px (BBox × 2.5)")
                
                # Crop-Koordinaten berechnen (zentriert um BBox)
                crop_x1 = bbox_center_x - crop_size // 2
                crop_y1 = bbox_center_y - crop_size // 2
                crop_x2 = crop_x1 + crop_size
                crop_y2 = crop_y1 + crop_size
                
                # Sicherstellen, dass Crop innerhalb der Bildgrenzen bleibt
                crop_x1 = max(0, crop_x1)
                crop_y1 = max(0, crop_y1)
                crop_x2 = min(original_image.width, crop_x2)
                crop_y2 = min(original_image.height, crop_y2)
                
                # Falls Crop zu klein ist, anpassen
                actual_crop_width = crop_x2 - crop_x1
                actual_crop_height = crop_y2 - crop_y1
                
                if actual_crop_width < crop_size or actual_crop_height < crop_size:
                    # An Kanten anpassen
                    if crop_x1 == 0:
                        crop_x2 = min(original_image.width, crop_size)
                    elif crop_x2 == original_image.width:
                        crop_x1 = max(0, original_image.width - crop_size)
                    
                    if crop_y1 == 0:
                        crop_y2 = min(original_image.height, crop_size)
                    elif crop_y2 == original_image.height:
                        crop_y1 = max(0, original_image.height - crop_size)
                
                print(f"   🔲 Crop-Bereich: [{crop_x1}, {crop_y1}, {crop_x2}, {crop_y2}]")
                print(f"   📏 Tatsächliche Crop-Größe: {crop_x2-crop_x1} × {crop_y2-crop_y1} px")
                
                # Bild ausschneiden
                cropped_image = original_image.crop((crop_x1, crop_y1, crop_x2, crop_y2))
                print(f"   ✅ Quadratischer Ausschnitt erstellt: {cropped_image.size}")
                
                # ============================================================
                # SCHRITT 3: BBox-Koordinaten transformieren
                # ============================================================
                print("📐 SCHRITT 3: BBox-KOORDINATEN TRANSFORMIEREN")
                rel_x1 = x1 - crop_x1
                rel_y1 = y1 - crop_y1
                rel_x2 = x2 - crop_x1
                rel_y2 = y2 - crop_y1
                
                # Sicherstellen, dass BBox innerhalb des Crops liegt
                rel_x1 = max(0, rel_x1)
                rel_y1 = max(0, rel_y1)
                rel_x2 = min(cropped_image.width, rel_x2)
                rel_y2 = min(cropped_image.height, rel_y2)
                
                print(f"   🎯 Relative BBox im Crop: [{rel_x1}, {rel_y1}, {rel_x2}, {rel_y2}]")
                print(f"   📏 Relative BBox Größe: {rel_x2-rel_x1} × {rel_y2-rel_y1} px")
                
                # ============================================================
                # SCHRITT 4: INTENSIVE BILDAUFBEREITUNG FÜR GESICHTSERKENNUNG
                # ============================================================
                print("🔍 SCHRITT 4: ERWEITERTE BILDAUFBEREITUNG FÜR GESICHTSERKENNUNG")
                
                # 1. Kontrast verstärken
                contrast_enhancer = ImageEnhance.Contrast(cropped_image)
                enhanced_image = contrast_enhancer.enhance(1.8)  # 80% mehr Kontrast
                
                # 2. Schärfe erhöhen für bessere Kantenerkennung
                sharpness_enhancer = ImageEnhance.Sharpness(enhanced_image)
                enhanced_image = sharpness_enhancer.enhance(2.0)  # 100% mehr Schärfe
                
                # 3. Helligkeit anpassen
                brightness_enhancer = ImageEnhance.Brightness(enhanced_image)
                enhanced_image = brightness_enhancer.enhance(1.1)  # 10% heller
                
                print(f"   ✅ Erweiterte Bildaufbereitung abgeschlossen")
                print(f"     • Kontrast: +80%")
                print(f"     • Schärfe: +100%")
                print(f"     • Helligkeit: +10%")
                
                # Für SAM: Verwende aufbereiteten Ausschnitt
                image = enhanced_image
                x1, y1, x2, y2 = rel_x1, rel_y1, rel_x2, rel_y2
                
                print("   🔄 SAM wird auf aufbereitetem Ausschnitt ausgeführt")
                print(f"   📊 SAM-Eingabegröße: {image.size}")
            
            # ============================================================
            # GEMEINSAME SAM-LOGIK FÜR ALLE MODI
            # ============================================================
            print("-" * 60)
            print(f"📦 BOUNDING BOX DETAILS FÜR SAM:")
            print(f"   Bild-Größe für SAM: {image.size}")
            print(f"   BBox Koordinaten: [{x1}, {y1}, {x2}, {y2}]")
            print(f"   BBox Dimensionen: {x2-x1}px × {y2-y1}px")
            
            # 3. Vorbereitung für SAM2 - WICHTIG: NUR EINE BBOX
            print("-" * 60)
            print("🖼️  BILDAUFBEREITUNG FÜR SAM 2")
            image_np = np.array(image.convert("RGB"))
            
            # Immer nur eine BBox verwenden (SAM 2 erwartet genau 1)
            input_boxes = [[[x1, y1, x2, y2]]]

            # 1. Punkt in der BBox-Mitte (zur Ünterstützung von SAM damit BBox nicht zu dicht um Kopf gezogen werden muß!)
            center_x = (x1 + x2) // 2
            center_y = (y1 + y2) // 2

            # 2. Punkt im Gesicht (30% höher vom Mittelpunkt)(auch für größere BBox)
            bbox_height = y2 - y1
            face_offset = int(bbox_height * 0.3)
            face_x = center_x
            face_y = center_y - face_offset
            face_y = max(y1 + 10, min(face_y, y2 - 10))  # In BBox halten

            # BEIDE Punkte kombinieren
            input_points = [[[[center_x, center_y], [face_x, face_y]]]] # ZWEI Punkte
            input_labels = [[[1, 1]]]  # Beide sind positive Prompts

            print(f"   🎯 SAM-Prompt: BBox [{x1},{y1},{x2},{y2}]")
            print(f"   👁️  Punkte: Mitte ({center_x},{center_y}), Gesicht ({face_x},{face_y})")


            # Aufruf des SAM-Prozessors mit den Variablen. Der Processor verpackt diese Rohdaten 
            # in die für das SAM-Modell erforderlichen Tensoren und speichert sie in inputs.
            inputs = self.sam_processor(
                image_np, 
                input_boxes=input_boxes,
                input_points=input_points,    # ZWEI Punkte
                input_labels=input_labels,    # Zwei Labels
                return_tensors="pt"
            ).to(self.device)                 # Ohne .to(self.device) werden die Tensoren standardmäßig im CPU-RAM erzeugt und gespeichert! Da GPU-Fehler!

            print(f"✅ Processor-Ausgabe: Dictionary mit {len(inputs)} Schlüsseln: {list(inputs.keys())}")
            print(f"   - 'pixel_values' Shape: {inputs['pixel_values'].shape}")
            print(f"   - 'input_boxes' Shape: {inputs['input_boxes'].shape}")
            if 'input_points' in inputs:
                print(f"   - 'input_points' Shape: {inputs['input_points'].shape}")
           

            # 4. SAM2 Vorhersage
            print("-" * 60)
            print("🧠 SAM 2 INFERENZ (Vorhersage)")
            with torch.no_grad():
                print("   Führe Vorhersage durch...")
                outputs = self.sam_model(**inputs)
                print(f"✅ Vorhersage abgeschlossen")
                print(f"   Anzahl der Vorhersagemasken: {outputs.pred_masks.shape[2]}")
            
            # 5. Maske extrahieren
            print("📏 SCHRITT 6: MASKE EXTRAHIEREN")
            
            num_masks = outputs.pred_masks.shape[2]
            print(f"   SAM lieferte {num_masks} verschiedene Masken")
            
            # Extrahiere alle Masken
            all_masks = []
            
            for i in range(num_masks):
                single_mask = outputs.pred_masks[:, :, i, :, :]
                resized_mask = F.interpolate(
                    single_mask,
                    size=(image.height, image.width),
                    mode='bilinear',
                    align_corners=False
                ).squeeze()
                
                mask_np = resized_mask.sigmoid().cpu().numpy()
                all_masks.append(mask_np)
                
                # Basis-Statistiken für jede Maske
                mask_binary = (mask_np > 0.5).astype(np.uint8)
                mask_area = np.sum(mask_binary)
                print(f"   Maske {i+1}: Größe={mask_area:,} Pixel, Max-Konfidenz={mask_np.max():.3f}")
            
            # ============================================================
            # MODUS-SPEZIFISCHE HEURISTIK
            # ============================================================
            print("🤔 SCHRITT 6: MASKENAUSWAHL MIT MODUS-SPEZIFISCHER HEURISTIK")
            
            bbox_center = ((x1 + x2) // 2, (y1 + y2) // 2)
            bbox_area = (x2 - x1) * (y2 - y1)
            print(f"   Erwartetes BBox-Zentrum: {bbox_center}")
            print(f"   Erwartete BBox-Fläche: {bbox_area:,} Pixel")
            
            best_mask_idx = 0
            best_score = -1
            
            for i, mask_np in enumerate(all_masks):
                mask_max = mask_np.max()
                
                # Grundlegende Filterung
                if mask_max < 0.3:
                    print(f"   ❌ Maske {i+1}: Zu niedrige Konfidenz ({mask_max:.3f}), überspringe")
                    continue
                
                # Adaptiver Threshold
                adaptive_threshold = max(0.3, mask_max * 0.7)
                mask_binary = (mask_np > adaptive_threshold).astype(np.uint8)
                
                if np.sum(mask_binary) == 0:
                    print(f"   ❌ Maske {i+1}: Keine Pixel nach Threshold {adaptive_threshold:.3f}")
                    continue
                
                mask_area_pixels = np.sum(mask_binary)
                
                # ============================================================
                # SPEZIALHEURISTIK NUR FÜR GESICHTSMODUS
                # ============================================================
                if mode == "face_only_change":
                    print(f"   🔍 Analysiere Maske {i+1} mit GESICHTS-HEURISTIK")
                    
                    # 1. FLÄCHENBASIERTE BEWERTUNG (40%)
                    area_ratio = mask_area_pixels / bbox_area
                    print(f"     📐 Flächen-Ratio: {area_ratio:.3f} ({mask_area_pixels:,} / {bbox_area:,} Pixel)")
                    
                    # Optimale Kopfgröße: 80-120% der BBox
                    if area_ratio < 0.6:
                        print(f"     ⚠️  Fläche zu klein für Kopf (<60% der BBox)")
                        area_score = area_ratio * 0.5  # Stark bestrafen
                    elif area_ratio > 1.5:
                        print(f"     ⚠️  Fläche zu groß für Kopf (>150% der BBox)")
                        area_score = 2.0 - area_ratio  # Linear bestrafen
                    elif 0.8 <= area_ratio <= 1.2:
                        area_score = 1.0  # Perfekte Größe
                        print(f"     ✅ Perfekte Kopfgröße (80-120% der BBox)")
                    else:
                        # Sanfte Abweichung
                        area_score = 1.0 - abs(area_ratio - 1.0) * 0.5
                    
                    # 2. KOMPAKTHEIT/SOLIDITÄT (30%)
                    labeled_mask = measure.label(mask_binary)
                    regions = measure.regionprops(labeled_mask)
                    
                    if len(regions) == 0:
                        compactness_score = 0.1
                        print(f"     ❌ Keine zusammenhängenden Regionen gefunden")
                    else:
                        # Größte Region finden (sollte der Kopf sein)
                        largest_region = max(regions, key=lambda r: r.area)
                        
                        # Solidität = Fläche / konvexe Hüllenfläche
                        solidity = largest_region.solidity if hasattr(largest_region, 'solidity') else 0.7
                        
                        # Exzentrizität (wie elliptisch) - Köpfe sind tendenziell elliptisch
                        eccentricity = largest_region.eccentricity if hasattr(largest_region, 'eccentricity') else 0.5
                        
                        # Perfekt runde Formen (Kreis) sind 0, Linie wäre 1
                        # Köpfe haben typischerweise 0.5-0.8
                        if 0.4 <= eccentricity <= 0.9:
                            eccentricity_score = 1.0 - abs(eccentricity - 0.65) * 2
                        else:
                            eccentricity_score = 0.2
                        
                        compactness_score = (solidity * 0.6 + eccentricity_score * 0.4)
                        print(f"     🎯 Kompaktheits-Analyse:")
                        print(f"       • Solidität (Fläche/Konvex): {solidity:.3f}")
                        print(f"       • Exzentrizität (Form): {eccentricity:.3f}")
                        print(f"       • Kompaktheits-Score: {compactness_score:.3f}")
                    
                    # 3. BBOX-ÜBERLAPPUNG (20%)
                    bbox_mask = np.zeros((image.height, image.width), dtype=np.uint8)
                    bbox_mask[y1:y2, x1:x2] = 1
                    overlap = np.sum(mask_binary & bbox_mask)
                    bbox_overlap_ratio = overlap / mask_area_pixels if mask_area_pixels > 0 else 0
                    
                    # Für Kopf: Sollte großteils in BBox sein (mind. 70%)
                    if bbox_overlap_ratio >= 0.7:
                        bbox_score = 1.0
                        print(f"     ✅ Hohe BBox-Überlappung: {bbox_overlap_ratio:.3f} ({overlap:,} Pixel)")
                    elif bbox_overlap_ratio >= 0.5:
                        bbox_score = bbox_overlap_ratio * 1.2
                        print(f"     ⚠️  Mittlere BBox-Überlappung: {bbox_overlap_ratio:.3f}")
                    else:
                        bbox_score = bbox_overlap_ratio * 0.8
                        print(f"     ❌ Geringe BBox-Überlappung: {bbox_overlap_ratio:.3f}")
                    
                    # 4. SAM-KONFIDENZ (10%)
                    confidence_score = mask_max
                    
                    # GESAMTSCORE für Gesicht
                    score = (
                        area_score * 0.4 +      # 40% Flächenpassung
                        compactness_score * 0.3 + # 30% Kompaktheit
                        bbox_score * 0.2 +      # 20% BBox-Überlappung
                        confidence_score * 0.1   # 10% Konfidenz
                    )
                    
                    print(f"     📊 GESICHTS-SCORES für Maske {i+1}:")
                    print(f"       • Flächen-Score: {area_score:.3f}")
                    print(f"       • Kompaktheits-Score: {compactness_score:.3f}")
                    print(f"       • BBox-Überlappungs-Score: {bbox_score:.3f}")
                    print(f"       • Konfidenz-Score: {confidence_score:.3f}")
                    print(f"       • GESAMTSCORE: {score:.3f}")
                
                # ============================================================
                # STANDARD-HEURISTIK FÜR ANDERE MODI
                # ============================================================
                else:
                    # Standard Heuristik für focus_change und environment_change
                    bbox_mask = np.zeros((image.height, image.width), dtype=np.uint8)
                    bbox_mask[y1:y2, x1:x2] = 1
                    
                    overlap = np.sum(mask_binary & bbox_mask)
                    bbox_overlap_ratio = overlap / np.sum(bbox_mask) if np.sum(bbox_mask) > 0 else 0
                    
                    # Schwerpunkt berechnen
                    y_coords, x_coords = np.where(mask_binary > 0)
                    if len(y_coords) > 0:
                        centroid_y = np.mean(y_coords)
                        centroid_x = np.mean(x_coords)
                        centroid_distance = np.sqrt((centroid_x - bbox_center[0])**2 + (centroid_y - bbox_center[1])**2)
                        normalized_distance = centroid_distance / max(image.width, image.height)
                    else:
                        normalized_distance = 1.0
                    
                    # Flächen-Ratio
                    area_ratio = mask_area_pixels / bbox_area
                    area_score = 1.0 - min(abs(area_ratio - 1.0), 1.0)
                    
                    # Konfidenz
                    confidence_score = mask_max
                    
                    # Standard-Score
                    score = (
                        bbox_overlap_ratio * 0.4 +
                        (1.0 - normalized_distance) * 0.25 +
                        area_score * 0.25 +
                        confidence_score * 0.1
                    )
                    
                    print(f"   📊 STANDARD-SCORES für Maske {i+1}:")
                    print(f"     • BBox-Überlappung: {bbox_overlap_ratio:.3f}")
                    print(f"     • Zentrums-Distanz: {centroid_distance if 'centroid_distance' in locals() else 'N/A'}")
                    print(f"     • Flächen-Ratio: {area_ratio:.3f}")
                    print(f"     • GESAMTSCORE: {score:.3f}")
                
                if score > best_score:
                    best_score = score
                    best_mask_idx = i
                    print(f"     🏆 Neue beste Maske: Nr. {i+1} mit Score {score:.3f}")
            
            print(f"✅ Beste Maske ausgewählt: Nr. {best_mask_idx+1} mit Score {best_score:.3f}")
            
            # Beste Maske verwenden
            mask_np = all_masks[best_mask_idx]
            
            # ============================================================
            # OPTIMIERTER THRESHOLD 
            # SAM gibt nur Wahrscheinlichkeiten aus!
            # Nachdem das Modell eine Maske für eine Person vorhersagt (wo jeder Pixel einen Wert zwischen 0 und 1 hat, 
            # wie "wahrscheinlich gehört dieser Pixel zur Person"), wird diese Maske binarisiert (0 oder 1), indem alle 
            # Pixel unter 0.05 auf 0 gesetzt werden, alle darüber auf 1.
            # ============================================================
            max_val = mask_np.max()
            print(f"   🔍 Maximaler SAM-Konfidenzwert der besten Maske: {max_val:.3f}")
            
            if mode == "face_only_change":
                # Spezieller Threshold für Gesichter
                if max_val < 0.5:
                    dynamic_threshold = 0.25
                    print(f"   ⚠️  SAM ist unsicher für Gesicht (max_val={max_val:.3f} < 0.5)")
                elif max_val < 0.8:
                    dynamic_threshold = max_val * 0.65  # Mittlerer Threshold
                    print(f"   ℹ️  SAM ist mäßig sicher für Gesicht (max_val={max_val:.3f})")
                else:
                    dynamic_threshold = max_val * 0.75  # Hoher Threshold
                    print(f"   ✅ SAM ist sicher für Gesicht (max_val={max_val:.3f} >= 0.8)")
                
                print(f"   🎯 Gesichts-Threshold: {dynamic_threshold:.3f}")
                
            elif mode == "focus_change":
                # SPEZIALBEHANDLUNG für Fokus-Änderung
                print("   🎯 FOCUS-CHANGE: Passe Threshold für vollständige Körpermaske an")
                if best_score < 0.7:  # Wenn Maskenqualität schlecht ist
                    dynamic_threshold = 0.05 #0.05 bedeutet, dass nur Pixel beibehalten werden, deren vorhergesagte Maskenwahrscheinlichkeit über 5% liegt.
                    print(f"   ⚠️  Masken-Score niedrig ({best_score:.3f}). Setze Threshold auf {dynamic_threshold:.3f} für maximale Abdeckung.")
                else:
                    # Bei guter Maske: moderaten Threshold verwenden
                    dynamic_threshold = max(0.15, max_val * 0.3)  # Viel niedriger als 0.8!
                    print(f"   ✅ Gute Maske. Verwende moderaten Threshold: {dynamic_threshold:.3f}")
                    
            else:  # environment_change oder andere
                # Alte Standardlogik (kann beibehalten werden)
                if max_val < 0.6:
                    dynamic_threshold = 0.3
                    print(f"   ⚠️  SAM ist unsicher (max_val={max_val:.3f} < 0.6)")
                else:
                    dynamic_threshold = max_val * 0.8          
                    print(f"   ✅ SAM ist sicher (max_val={max_val:.3f} >= 0.6)")
                
                
               
            
            print(f"   🐛 DEBUG THRESHOLD: max_val={max_val:.3f}, dynamic_threshold={dynamic_threshold:.3f}")
            mask_array = (mask_np > dynamic_threshold).astype(np.uint8) * 255
            print(f"   🚨 URSPSRUNGS-DEBUG 1: mask_np Min/Max: {mask_np.min():.3f}/{mask_np.max():.3f}")
            print(f"   🚨 URSPSRUNGS-DEBUG 2: mask_array Min/Max: {mask_array.min()}/{mask_array.max()}, Sum: {mask_array.sum()}")
            print(f"   🚨 URSPSRUNGS-DEBUG 3: Sind mask_np und mask_array gleich? {np.array_equal(mask_np > dynamic_threshold, mask_array > 0)}")
            print(f"   🚨 URSPSRUNGS-DEBUG 4: Weiße Pixel in mask_array: {np.sum(mask_array > 0)}")
            print(f"   🚨 URSPSRUNGS-DEBUG 5: Anteil weiße Pixel: {np.sum(mask_array > 0) / mask_array.size:.1%}")
            print(f"   🐛 DEBUG BINÄRMASKE: Min/Max: {mask_array.min()}/{mask_array.max()}, Weiße Pixel: {np.sum(mask_array > 0)}")
            #mask_array = (mask_np > dynamic_threshold).astype(np.uint8) * 255

            # 2. Wenn die Maske immer noch leer ist, ERZwinge eine einfache Maske für den Test:
            if mask_array.max() == 0:
                print("   ⚠️  KRITISCH: Binärmaske ist leer! Erzwinge Testmaske (BBox).")
                print(f"   🚨 BBox für Fallback: x1={x1}, y1={y1}, x2={x2}, y2={y2}")
                # Erstelle eine einfache weiße Box innerhalb der BBox als Fallback
                test_mask = np.zeros((image.height, image.width), dtype=np.uint8)
                cv2.rectangle(test_mask, (x1, y1), (x2, y2), 255, -1)  # -1 = ausgefüllt
                
                mask_array = test_mask
                print(f"   🐛 DEBUG ERZWUNGENE MASKE: Min/Max: {mask_array.min()}/{mask_array.max()}")
                print(f"   🐛 DEBUG ERZWUNGENE MASKE Weiße Pixel: {np.sum(mask_array > 0)}")

                mask_np = mask_array.astype(np.float32) / 255.0
                print("   ✅ Fallback-Maske wurde gesetzt und mask_np aktualisiert.")


            # Direkt VOR raw_mask_array = mask_array.copy():
            print("=" * 60)
            print("🔍 FINALE MASKE VOR RÜCKGABE:")
            print(f"   mask_array - Min/Max: {mask_array.min()}/{mask_array.max()}")
            print(f"   mask_array - Weiße Pixel: {np.sum(mask_array > 0)}")
            print(f"   mask_array - Shape: {mask_array.shape}")
            print(f"   mask_array - dtype: {mask_array.dtype}")

            # KRITISCHE PRÜFUNG: Ist die Maske überhaupt sichtbar?
            if mask_array.max() == 0:
                print("   ⚠️  ⚠️  ⚠️  KRITISCH: Maske ist KOMPLETT SCHWARZ vor Rückgabe!")
                print("   🎯 SOFORT-FIX: Setze Maske auf einfache Box (100% weiß)")
                # Erstelle eine 100% weiße Maske in BBox-Größe
                mask_array = np.ones((image.height, image.width), dtype=np.uint8) * 255
                print(f"   ✅ FORCIERTE VOLLE MASKE: Min/Max: {mask_array.min()}/{mask_array.max()}")
            else:
                print(f"   ✅ Maske hat Inhalt: {np.sum(mask_array > 0) / mask_array.size:.1%} weiß")
                print("=" * 60)    

            # HIER: Rohmaske speichern (vor Smoothing)
            raw_mask_array = mask_array.copy()

                        
            # ============================================================
            # MODUS-SPEZIFISCHES POSTPROCESSING
            # ============================================================
            print("🔧 SCHRITT 7: MODUS-SPEZIFISCHES POSTPROCESSING")
            
            if mode == "face_only_change":
                print("👤 GESICHTS-SPEZIFISCHES POSTPROCESSING")
                
                # 1. Größte zusammenhängende Komponente finden
                labeled_array, num_features = ndimage.label(mask_array)
                
                if num_features > 0:
                    print(f"   🔍 Gefundene Komponenten: {num_features}")
                    
                    sizes = ndimage.sum(mask_array, labeled_array, range(1, num_features + 1))
                    largest_component_idx = np.argmax(sizes) + 1
                    
                    print(f"   👑 Größte Komponente: Nr. {largest_component_idx} mit {sizes[largest_component_idx-1]:,} Pixel")
                    
                    # NUR die größte Komponente behalten (der Kopf)
                    mask_array = np.where(labeled_array == largest_component_idx, mask_array, 0)
                    
                    # 2. MORPHOLOGISCHE OPERATIONEN FÜR SAUBEREN KOPF
                    print("   ⚙️  Morphologische Operationen für sauberen Kopf")
                    
                    # Zuerst CLOSE, um kleine Löcher im Kopf zu füllen
                    kernel_close = np.ones((7, 7), np.uint8)
                    mask_array = cv2.morphologyEx(mask_array, cv2.MORPH_CLOSE, kernel_close, iterations=1)
                    print("     • MORPH_CLOSE (7x7) - Löcher im Kopf füllen")
                    
                    # Dann OPEN, um kleine Ausreißer zu entfernen
                    kernel_open = np.ones((5, 5), np.uint8)
                    mask_array = cv2.morphologyEx(mask_array, cv2.MORPH_OPEN, kernel_open, iterations=1)
                    print("     • MORPH_OPEN (5x5) - Rauschen entfernen")
                
                # ============================================================
                # KRITISCH: MASKE IMMER ZURÜCK AUF ORIGINALGRÖSSE (auch bei Fallback!)
                # ============================================================
                print("-" * 60)
                print("🔄 MASKE IMMER ZURÜCK AUF ORIGINALGRÖSSE TRANSFORMIEREN")
                
                # WICHTIG: Immer die richtigen Crop-Koordinaten verwenden
                temp_mask = Image.fromarray(mask_array).convert("L")
                print(f"   Maskengröße auf Ausschnitt: {temp_mask.size}")
                
                # Maske auf ORIGINALBILDGRÖSSE bringen
                final_mask = Image.new("L", original_image.size, 0)
                print(f"   Leere Maske in Originalgröße: {final_mask.size}")
                
                # Immer die gespeicherten Crop-Koordinaten verwenden
                if crop_x1 is not None and crop_y1 is not None:
                    final_mask.paste(temp_mask, (crop_x1, crop_y1))
                    print(f"   Maskenposition im Original: ({crop_x1}, {crop_y1})")
                else:
                    # Fallback: Zentrieren
                    x_offset = (original_image.width - temp_mask.width) // 2
                    y_offset = (original_image.height - temp_mask.height) // 2
                    final_mask.paste(temp_mask, (x_offset, y_offset))
                    print(f"   ⚠️  Keine Crop-Koordinaten, zentriert: ({x_offset}, {y_offset})")
                
                mask_array = np.array(final_mask)
                print(f"   ✅ Maske zurück auf Originalgröße skaliert: {mask_array.shape}")
                
                # Bild-Referenz zurücksetzen
                image = original_image
                print(f"   🔄 Bild-Referenz wieder auf Original gesetzt: {image.size}")
                            

            elif mode == "focus_change":
                print("🎯 FOCUS-CHANGE POSTPROCESSING")
                # DEBUG: Zustand der Maske VOR der Bearbeitung
                print(f"   DEBUG VORHER - Min/Max: {mask_array.min()}/{mask_array.max()}, Typ: {mask_array.dtype}")
                
                # Für focus_change: Originalbildgröße beibehalten
                if image.size != original_image.size:
                    print(f"   ⚠️  Bildgröße angepasst: {image.size} → {original_image.size}")
                    temp_mask = Image.fromarray(mask_array).convert("L")
                    temp_mask = temp_mask.resize(original_image.size, Image.Resampling.NEAREST)
                    mask_array = np.array(temp_mask)
                
                mask_array = mask_array.copy()
                
                # Größte weiße Komponente behalten (Person)
                labeled_array, num_features = ndimage.label(mask_array)
                if num_features > 1:
                    sizes = ndimage.sum(mask_array, labeled_array, range(1, num_features + 1))
                    largest_component = np.argmax(sizes) + 1
                    mask_array = np.where(labeled_array == largest_component, mask_array, 0)
                    print(f"   ✅ Behalte größte Person-Komponente ({num_features} → 1 Komponente)")
                    print(f"   DEBUG NACH Komponentenfilter - Min/Max: {mask_array.min()}/{mask_array.max()}")
      
    
                # 1. Zuerst CLOSE, um schwarze Löcher IN der Person zu füllen
                kernel_close = np.ones((5,5), np.uint8)
                mask_array = cv2.morphologyEx(mask_array, cv2.MORPH_CLOSE, kernel_close, iterations=3)
                print(f"   DEBUG NACH MORPH_CLOSE - Min/Max: {mask_array.min()}/{mask_array.max()}")
    
                # 2. Dann Dilation für bessere Abdeckung
                kernel_dilate_large = np.ones((25,25), np.uint8)
                mask_array = cv2.dilate(mask_array, kernel_dilate_large, iterations=2)
                print(f"   DEBUG NACH DILATION - Min/Max: {mask_array.min()}/{mask_array.max()}")
                print(f"   🐛 DEBUG NACH VERSTÄRKTER DILATION - Min/Max: {mask_array.min()}/{mask_array.max()}, Weiße Pixel: {np.sum(mask_array > 0)}")

                # Mittelstarker Blur für natürliche Übergänge:
                mask_array = cv2.GaussianBlur(mask_array, (9, 9), 2.0)

                # Alternativen:
                # Sanfter: (7, 7), 1.5 → subtiler Übergang
                # Stärker: (11, 11), 2.5 → sehr weiche Übergänge

                # Mittelstarker Blur für natürliche Übergänge:
                mask_array = cv2.GaussianBlur(mask_array, (9, 9), 2.0)
                
                # GAMMA-KORREKTUR gegen milchige Ränder (Float-Bereich 0-1 nötig)
                mask_array = mask_array.astype(np.float32) / 255.0  # <-- WICHTIG: ZUERST in 0-1 konvertieren
                print(f"   DEBUG NACH Float-Konvertierung - Min/Max: {mask_array.min():.3f}/{mask_array.max():.3f}, Typ: {mask_array.dtype}")
                mask_array = np.clip(mask_array, 0.0, 1.0)
                mask_array = mask_array ** 0.85   # Gamma-Korrektur anwenden
                print(f"   DEBUG NACH Gamma-Korrektur - Min/Max: {mask_array.min():.3f}/{mask_array.max():.3f}")
                mask_array = (mask_array * 255).astype(np.uint8)   # Zurück in 0-255
                print(f"   DEBUG NACH Rückkonvertierung - Min/Max: {mask_array.min()}/{mask_array.max()}, Typ: {mask_array.dtype}")
    
                print("   ✅ MORPH_CLOSE füllt schwarze Löcher in der Person")
                print("   ✅ Dilation für bessere Personenabdeckung")    
                print(f"   🔄 Konvertiert zu Float32 im Bereich [0, 1]. Neuer min/max: {mask_array.min():.3f}/{mask_array.max():.3f}")
                print(f"   ⚙️  Gamma-Korrektur (0.85) angewendet. Neuer min/max: {mask_array.min():.3f}/{mask_array.max():.3f}")
                print(f"   ✅ Zurück zu uint8 [0, 255]. Final min/max: {mask_array.min()}/{mask_array.max()}")

            
            elif mode == "environment_change":
                print("🌳 ENVIRONMENT-CHANGE POSTPROCESSING")
                
                # Für environment_change: Originalbildgröße beibehalten
                if image.size != original_image.size:
                    print(f"   ⚠️  Bildgröße angepasst: {image.size} → {original_image.size}")
                    temp_mask = Image.fromarray(mask_array).convert("L")
                    temp_mask = temp_mask.resize(original_image.size, Image.Resampling.NEAREST)
                    mask_array = np.array(temp_mask)
                
                mask_array = 255 - mask_array  # Invertiere Maske
                print("   ✅ Maske invertiert (Person schwarz, Hintergrund weiß)")
                
                # Weiße Punkte in der Person (schwarz) entfernen
                kernel_open = np.ones((3,3), np.uint8)
                mask_array = cv2.morphologyEx(mask_array, cv2.MORPH_OPEN, kernel_open, iterations=3)
                print("   ✅ MORPH_OPEN entfernt weiße Punkte in der Person")
                
                # Morphologische Operationen für saubere Umgebung
                kernel_close = np.ones((5,5), np.uint8)
                mask_array = cv2.morphologyEx(mask_array, cv2.MORPH_CLOSE, kernel_close)
                print("   ✅ MORPH_CLOSE für zusammenhängende Umgebung")
                
                # Weiche Ränder für bessere Integration der Person
                mask_array = cv2.GaussianBlur(mask_array, (9, 9), 2.0)
                print("   ✅ Gaussian Blur für weiche Übergänge")
                
                # Gamma-Korrektur für präzisere Ränder
                mask_array = mask_array.astype(np.float32) / 255.0
                mask_array = np.clip(mask_array, 0.0, 1.0)
                mask_array = mask_array ** 0.85
                mask_array = (mask_array * 255).astype(np.uint8)
                print("   ✅ Gamma-Korrektur (0.85) gegen milchige Ränder")

                # QUALITÄTSKONTROLLE
                #white_pixels = np.sum(mask_array > 127)
                #total_pixels = mask_array.size
                #white_ratio = white_pixels / total_pixels * 100  
                                     
            #print("-" * 60)
            #print("📊 MASKEN-STATISTIK (FINAL)")
            #print(f"   Weiße Pixel (Veränderungsbereich): {white_pixels:,} ({white_ratio:.1f}%)")
            #print(f"   Schwarze Pixel (Erhaltungsbereich): {total_pixels-white_pixels:,} ({100-white_ratio:.1f}%)")
            #print(f"   Gesamtpixel: {total_pixels:,}")
            
            if mode == "face_only_change":
                original_face_area = original_bbox_size[0] * original_bbox_size[1]
                coverage_ratio = white_pixels / original_face_area if original_face_area > 0 else 0
                print(f"   👤 GESICHTSABDECKUNG: {coverage_ratio:.1%} der ursprünglichen BBox")
                
                # Warnungen basierend auf Abdeckung
                if coverage_ratio < 0.7:
                    print(f"   ⚠️  WARNUNG: Geringe Gesichtsabdeckung ({coverage_ratio:.1%})")
                elif coverage_ratio > 1.3:
                    print(f"   ⚠️  WARNUNG: Sehr hohe Gesichtsabdeckung ({coverage_ratio:.1%})")
                elif 0.8 <= coverage_ratio <= 1.2:
                    print(f"   ✅ OPTIMALE Gesichtsabdeckung ({coverage_ratio:.1%})")

            # Zurück zu PIL Image
            mask = Image.fromarray(mask_array).convert("L")
            raw_mask = Image.fromarray(raw_mask_array).convert("L")
            
            print("#" * 80)
            print(f"✅ SAM 2 SEGMENTIERUNG ABGESCHLOSSEN")
            print(f"📐 Finale Maskengröße: {mask.size}")
            print(f"🎛️  Verwendeter Modus: {mode}")
            
            if mode == "face_only_change" and crop_size is not None:
                print(f"👤 Bei face_only_change: Crop={crop_size}×{crop_size}px, Heuristik-Score={best_score:.3f}")
                print(f"👤 Kopfabdeckung: {coverage_ratio:.1%} der BBox")

                
            # Vor der Zeile: print("#" * 80) oder return mask, raw_mask
            print(f"   DEBUG NACHHER - Min/Max: {mask_array.min()}/{mask_array.max()}, Typ: {mask_array.dtype}")
            print("#" * 80)
            return mask, raw_mask
        
        except Exception as e:
            print("❌" * 40)
            print("❌ FEHLER IN SAM 2 SEGMENTIERUNG")
            print("❌" * 40)
            print(f"Fehler: {str(e)[:200]}")
            import traceback
            traceback.print_exc()
            
            # WICHTIG: Im Fallback immer die richtige Größe zurückgeben
            print("ℹ️ Fallback auf rechteckige Maske")
            fallback_mask = self._create_rectangular_mask(original_image, original_bbox, mode)
            
            # Sicherstellen, dass die Maske die richtige Größe hat
            if fallback_mask.size != original_image.size:
                print(f"   ⚠️  Fallback-Maske angepasst: {fallback_mask.size} → {original_image.size}")
                fallback_mask = fallback_mask.resize(original_image.size, Image.Resampling.NEAREST)
            
            return fallback_mask, fallback_mask

    def _create_rectangular_mask(self, image, bbox_coords, mode):
        """Fallback: Erstellt rechteckige Maske"""
        print("#" * 80)
        print("# ⚠️  FALLBACK: ERSTELLE RECHTECKIGE MASKE")
        print("#" * 80)
        
        from PIL import ImageDraw

        mask = Image.new("L", image.size, 0)
        print(f"📐 Erstelle leere Maske: {mask.size}")

        if bbox_coords and all(coord is not None for coord in bbox_coords):
            x1, y1, x2, y2 = self._validate_bbox(image, bbox_coords)
            draw = ImageDraw.Draw(mask)

            if mode == "environment_change":
                draw.rectangle([0, 0, image.size[0], image.size[1]], fill=255)
                draw.rectangle([x1, y1, x2, y2], fill=0)
                print(f"   Modus: Umgebung ändern - BBox geschützt: [{x1}, {y1}, {x2}, {y2}]")
            else:
                draw.rectangle([x1, y1, x2, y2], fill=255)
                print(f"   Modus: Focus/Gesicht ändern - BBox verändert: [{x1}, {y1}, {x2}, {y2}]")

        print("✅ Rechteckige Maske erstellt")
        return mask

    def load_pose_detector(self):
        """Lädt nur den Pose-Detector"""
        if self.pose_detector is None:
            print("#" * 80)
            print("# 📥 LADE POSE DETECTOR")
            print("#" * 80)
            try:
                self.pose_detector = OpenposeDetector.from_pretrained("lllyasviel/ControlNet")
                print("✅ Pose-Detector geladen")
            except Exception as e:
                print(f"⚠️ Pose-Detector konnte nicht geladen werden: {e}")
        return self.pose_detector

    def load_midas_model(self):
        """Lädt MiDaS Model für Depth Maps"""
        if self.midas_model is None:
            print("#" * 80)
            print("# 📥 LADE MIDAS MODELL FÜR DEPTH MAPS")
            print("#" * 80)
            try:
                import torchvision.transforms as T

                self.midas_model = torch.hub.load(
                    "intel-isl/MiDaS",
                    "DPT_Hybrid",
                    trust_repo=True
                )

                self.midas_model.to(self.device)
                self.midas_model.eval()

                self.midas_transform = T.Compose([
                    T.Resize(384),
                    T.ToTensor(),
                    T.Normalize(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5]),
                ])

                print("✅ MiDaS Modell erfolgreich geladen")
            except Exception as e:
                print(f"❌ MiDaS konnte nicht geladen werden: {e}")
                print("ℹ️ Verwende Fallback-Methode")
                self.midas_model = None

        return self.midas_model

    def extract_pose_simple(self, image):
        """Einfache Pose-Extraktion ohne komplexe Abhängigkeiten"""
        print("#" * 80)
        print("# ⚠️  ERSTELLE EINFACHE POSE-MAP (FALLBACK)")
        print("#" * 80)
        try:
            img_array = np.array(image.convert("RGB"))
            edges = cv2.Canny(img_array, 100, 200)
            pose_image = Image.fromarray(edges).convert("RGB")
            print("⚠️ Verwende Kanten-basierte Pose-Approximation")
            return pose_image
        except Exception as e:
            print(f"Fehler bei einfacher Pose-Extraktion: {e}")
            return image.convert("RGB").resize((512, 512))

    def extract_pose(self, image):
        """Extrahiert Pose-Map aus Bild mit Fallback"""
        print("#" * 80)
        print("# 🕺 ERSTELLE POSE-MAP")
        print("#" * 80)
        try:
            detector = self.load_pose_detector()
            if detector is None:
                print("⚠️ Kein Pose-Detector verfügbar, verwende Fallback")
                return self.extract_pose_simple(image)

            print("   Extrahiere Pose mit OpenPose...")
            pose_image = detector(image, hand_and_face=True)
            print("✅ Pose-Map erfolgreich erstellt")
            return pose_image
        except Exception as e:
            print(f"Fehler bei Pose-Extraktion: {e}")
            return self.extract_pose_simple(image)

    def extract_canny_edges(self, image):
        """Extrahiert Canny Edges für Umgebungserhaltung"""
        print("#" * 80)
        print("# 🎨 ERSTELLE CANNY EDGE MAP")
        print("#" * 80)
        try:
            img_array = np.array(image.convert("RGB"))

            gray = cv2.cvtColor(img_array, cv2.COLOR_RGB2GRAY)
            edges = cv2.Canny(gray, 100, 200)

            edges_rgb = cv2.cvtColor(edges, cv2.COLOR_GRAY2RGB)
            edges_image = Image.fromarray(edges_rgb)

            print("✅ Canny Edge Map erstellt")
            return edges_image
        except Exception as e:
            print(f"Fehler bei Canny Edge Extraction: {e}")
            return image.convert("RGB").resize((512, 512))

    def extract_depth_map(self, image):
        """
        Extrahiert Depth Map mit MiDaS (Fallback auf Filter)
        """
        print("#" * 80)
        print("# 🏔️  ERSTELLE DEPTH MAP")
        print("#" * 80)
        try:
            midas = self.load_midas_model()
            if midas is not None:
                print("🎯 Verwende MiDaS für Depth Map...")

                import torchvision.transforms as T

                img_transformed = self.midas_transform(image).unsqueeze(0).to(self.device)

                with torch.no_grad():
                    print("   Führe MiDaS Inferenz durch...")
                    prediction = midas(img_transformed)
                    prediction = torch.nn.functional.interpolate(
                        prediction.unsqueeze(1),
                        size=image.size[::-1],
                        mode="bicubic",
                        align_corners=False,
                    ).squeeze()

                depth_np = prediction.cpu().numpy()
                depth_min, depth_max = depth_np.min(), depth_np.max()
                print(f"   Tiefenwerte: Min={depth_min:.3f}, Max={depth_max:.3f}")

                if depth_max > depth_min:
                    depth_np = (depth_np - depth_min) / (depth_max - depth_min)

                depth_np = (depth_np * 255).astype(np.uint8)
                depth_image = Image.fromarray(depth_np).convert("RGB")

                print("✅ MiDaS Depth Map erfolgreich erstellt")
                return depth_image

            else:
                raise Exception("MiDaS nicht geladen")

        except Exception as e:
            print(f"⚠️ MiDaS Fehler: {e}. Verwende Fallback...")
            try:
                img_array = np.array(image.convert("RGB"))
                gray = cv2.cvtColor(img_array, cv2.COLOR_RGB2GRAY)

                depth_map = cv2.GaussianBlur(gray, (5, 5), 0)
                depth_rgb = cv2.cvtColor(depth_map, cv2.COLOR_GRAY2RGB)
                depth_image = Image.fromarray(depth_rgb)

                print("✅ Fallback Depth Map erstellt")
                return depth_image
            except Exception as fallback_error:
                print(f"❌ Auch Fallback fehlgeschlagen: {fallback_error}")
                return image.convert("RGB").resize((512, 512))

    def prepare_controlnet_maps(self, image, keep_environment=False):
        """
        ERSTELLT NUR CONDITIONING-MAPS, generiert KEIN Bild.
        """
        print("#" * 80)
        print("# 🎯 STARTE CONTROLNET CONDITIONING-MAP ERSTELLUNG")
        print("#" * 80)
        print(f"📐 Eingabebild-Größe: {image.size}")
        print(f"🎛️  Modus: {'Depth + Canny' if keep_environment else 'OpenPose + Canny'}")

        if keep_environment:
            print("   Modus: Depth + Canny")
            print("   Schritt 1/2: Extrahiere Depth Map...")
            depth_map = self.extract_depth_map(image)
            print("   Schritt 2/2: Extrahiere Canny Edges...")
            canny_map = self.extract_canny_edges(image)
            conditioning_images = [depth_map, canny_map]
            extra_maps = {"depth": depth_map, "canny": canny_map}  # NEU
        else:
            print("   Modus: OpenPose + Canny")
            print("   Schritt 1/2: Extrahiere Pose Map...")
            pose_map = self.extract_pose(image)
            print("   Schritt 2/2: Extrahiere Canny Edges...")
            canny_map = self.extract_canny_edges(image)
            conditioning_images = [pose_map, canny_map]
            extra_maps = {"pose": pose_map, "canny": canny_map}

        print("-" * 60)
        print(f"✅ {len(conditioning_images)} CONDITIONING-MAPS ERSTELLT")
        for i, img in enumerate(conditioning_images):
            print(f"   Map {i+1}: {img.size}, Modus: {img.mode}")
        print("#" * 80)
        
        return conditioning_images, extra_maps


# Globale Instanz
device = "cuda" if torch.cuda.is_available() else "cpu"
torch_dtype = torch.float16 if device == "cuda" else torch.float32
controlnet_processor = ControlNetProcessor(device=device, torch_dtype=torch_dtype)