Update sam_module.py

sam_module.py

@@ -38,7 +38,7 @@ def create_sam_mask(self, image, bbox_coords, mode):
             print("-" * 60)
 
                 
-            # Bild für SAM vorbereiten
+            # Der Prozessor von SAM erwartet ein NumPy-Array kein PIL
             image_np = np.array(image.convert("RGB"))
 
             
@@ -531,6 +531,425 @@ def create_sam_mask(self, image, bbox_coords, mode):
         # ============================================================
         # BLOCK 3: FACE_ONLY_CHANGE
         # ============================================================
+        elif 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- 2,5 mal so groß und quadratisch wie BBox
+            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}")
+
+        #======Bei allen Modi gleich=====
+        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")
+            
+        # Vorbereitung für SAM2 - WICHTIG: NUR EINE BBOX
+        print("-" * 60)
+        print("🖼️  BILDAUFBEREITUNG FÜR SAM 2")
+        #SAM erwartet NumPy-Array, kein PIL
+        image_np = np.array(image.convert("RGB"))
+            
+        # Immer nur eine BBox verwenden (SAM 2 erwartet genau 1)
+        input_boxes = [[[x1, y1, x2, y2]]]
+
+        # 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
+
+        # 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}")
+            
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+# ============================================================
+# SPEZIALHEURISTIK FÜR GESICHTSMODUS (später im Code)
+# ============================================================
+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}")
+
+# ============================================================
+# THRESHOLD-BESTIMMUNG FÜR GESICHTSMODUS
+# ============================================================
+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}")
+
+# ============================================================
+# POSTPROCESSING FÜR GESICHTSMODUS
+# ============================================================
+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}")
+
+# ============================================================
+# ABSCHLIESSENDE STATISTIK FÜR GESICHTSMODUS
+# ============================================================
+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%})")
+
+# ============================================================
+# FINALE AUSGABE FÜR GESICHTSMODUS
+# ============================================================
+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")
+
+
+
+
+
+        
         elif mode == "face_only_change":
             print("-" * 60)
             print("👤 MODUS: FACE_ONLY_CHANGE")
@@ -572,4 +991,5 @@ def create_sam_mask(self, image, bbox_coords, mode):
             fallback_mask = fallback_mask.resize(original_image.size, Image.Resampling.NEAREST)
         
         return fallback_mask, fallback_mask
+