Update sam_module.py

sam_module.py

@@ -730,213 +730,226 @@ def create_sam_mask(self, image, bbox_coords, mode):
                 # 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}")
+                print(f"   Maske {i+1}: Größe={mask_area:,} Pixel, Max-Konfidenz={mask_np.max():.3f}")          
             
+            # ============================================================
+            # 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 
+                # ============================================================
 
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-# ============================================================
-# 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)
+                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
+                    # 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
+                    # 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
+                    # 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}")
+                    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}")
+    
+                # 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 
+                # ============================================================
+                # 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}")
 
-# ============================================================
-# 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 
+                # ============================================================
 
-# ============================================================
-# POSTPROCESSING FÜR GESICHTSMODUS
-# ============================================================
-if mode == "face_only_change":
-    print("👤 GESICHTS-SPEZIFISCHES POSTPROCESSING")
+                print("👤 GESICHTS-SPEZIFISCHES POSTPROCESSING")
     
-    # 1. Größte zusammenhängende Komponente finden
-    labeled_array, num_features = ndimage.label(mask_array)
+                # 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}")
+                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
+                    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")
+                    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)
+                    # 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")
+                    # 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")
+                    # 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%})")
+                    # 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
+                # ============================================================
+
+                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
@@ -950,19 +963,7 @@ if mode == "face_only_change" and crop_size is not None:
 
 
         
-        elif mode == "face_only_change":
-            print("-" * 60)
-            print("👤 MODUS: FACE_ONLY_CHANGE")
-            print("-" * 60)
-            
-            # ... existierende face_only_change Logik hier komplett ...
-            # (wird aus dem Original übernommen, nicht verändert)
-            
-            # WICHTIG: Du musst den face_only_change Code hier einfügen
-            # von Zeile ~252 bis ~650 aus dem Original
-            
-            # Beispiel-Struktur (vereinfacht):
-            # Crop, Punkte setzen, spezielle Gesichtsheuristik etc.
+         
             
             # Am Ende:
             mask = Image.new("L", (512, 512), 128)  # Platzhalter