Update sam_module.py

sam_module.py

@@ -37,11 +37,9 @@ def create_sam_mask(self, image, bbox_coords, mode):
             print("🌳 MODUS: ENVIRONMENT_CHANGE")
             print("-" * 60)
 
-                
             # Der Prozessor von SAM erwartet ein 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]]]
 
@@ -67,7 +65,7 @@ def create_sam_mask(self, image, bbox_coords, mode):
             num_masks = outputs.pred_masks.shape[2]
             print(f"   SAM lieferte {num_masks} verschiedene Masken")  
 
-            #Sammlung der Masken
+            # Sammlung der Masken
             all_masks = []
             
             for i in range(num_masks):
@@ -154,11 +152,11 @@ def create_sam_mask(self, image, bbox_coords, mode):
                     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}")
+                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
@@ -173,7 +171,6 @@ def create_sam_mask(self, image, bbox_coords, mode):
             max_val = mask_np.max()
             print(f"   🔍 Maximaler SAM-Konfidenzwert der besten Maske: {max_val:.3f}")
 
-
             if max_val < 0.6:
                 dynamic_threshold = 0.3
                 print(f"   ⚠️  SAM ist unsicher (max_val={max_val:.3f} < 0.6)")
@@ -181,15 +178,13 @@ def create_sam_mask(self, image, bbox_coords, mode):
                 dynamic_threshold = max_val * 0.8          
                 print(f"   ✅ SAM ist sicher (max_val={max_val:.3f} >= 0.6)")
 
-
             # Binärmaske erstellen (256x256)
             mask_array = (mask_np > dynamic_threshold).astype(np.uint8) * 255
 
-            
             # Fallback bei leerer Maske, der höchste Wert ist 0 also schwarz
             if mask_array.max() == 0:
                 print("   ⚠️  Maske leer, erstelle rechteckige Fallback-Maske")
-                mask_array = np.zeros((512, 512), dtype=np.uint8) * 255  #weiße 512x512-Maske
+                mask_array = np.zeros((512, 512), dtype=np.uint8) * 255  # weiße 512x512-Maske
                 
                 # Skaliere BBox auf 512x512
                 scale_x = 512 / image.width
@@ -202,10 +197,8 @@ def create_sam_mask(self, image, bbox_coords, mode):
                 # Schwarzes Rechteck für Person
                 cv2.rectangle(mask_array, (fb_x1, fb_y1), (fb_x2, fb_y2), 0, -1) 
 
-
             # Damit wird die Rohmaske für die UI-Anzeige gespeichert
             raw_mask_array = mask_array.copy()      
-            
 
             print("🌳 ENVIRONMENT-CHANGE POSTPROCESSING")   
     
@@ -217,19 +210,16 @@ def create_sam_mask(self, image, bbox_coords, mode):
                 mask_array = np.array(temp_mask)
                 print(f"   ✅ Maske auf Originalgröße skaliert: {mask_array.shape}")
          
-    
             # Maske invertieren (Person wird schwarz, Hintergrund weiß)
             mask_array = 255 - mask_array
             print("   ✅ Maske invertiert (Person schwarz, Hintergrund weiß)")
 
-                  
             # Weiße Punkte in der Person (schwarz) entfernen
             print("🧹 Entferne weiße Punkte in der Person...")
             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")
 
-    
             # DEBUG nach MORPH_OPEN
             print(f"   Nach MORPH_OPEN - Weiße Pixel: {np.sum(mask_array > 127)}")
     
@@ -278,7 +268,6 @@ def create_sam_mask(self, image, bbox_coords, mode):
             print(f"   Schwarze Pixel (PERSON - Erhaltung): {black_pixels:,} ({black_ratio:.1f}%)")
             print(f"   Gesamtpixel: {total_pixels:,}")
 
-
             # Warnungen basierend auf Verhältnis
             if white_ratio < 30:
                 print(f"   ⚠️  WARNUNG: Sehr wenig Hintergrund ({white_ratio:.1f}%)")
@@ -291,7 +280,6 @@ def create_sam_mask(self, image, bbox_coords, mode):
             else:
                 print(f"   ℹ️  Normales Verhältnis ({white_ratio:.1f}%)")
                 
-    
             # Zurück zu PIL Image
             mask = Image.fromarray(mask_array).convert("L")
             raw_mask = Image.fromarray(raw_mask_array).convert("L")
@@ -302,7 +290,7 @@ def create_sam_mask(self, image, bbox_coords, mode):
             print(f"🎛️  Verwendeter Modus: {mode}")
             print("#" * 80)            
                         
-            return mask, raw_mask  #in mask steht die invertierte nachbearbeitete Maske, in raw_mask die Rohmaske
+            return mask, raw_mask  # in mask steht die invertierte nachbearbeitete Maske, in raw_mask die Rohmaske
             
         # ============================================================
         # BLOCK 2: FOCUS_CHANGE
@@ -344,8 +332,9 @@ def create_sam_mask(self, image, bbox_coords, mode):
                 print(f"✅ Vorhersage abgeschlossen")
                 print(f"   Anzahl der Vorhersagemasken: {outputs.pred_masks.shape[2]}")
 
+            num_masks = outputs.pred_masks.shape[2]
             
-            #Sammlung der Masken
+            # Sammlung der Masken
             all_masks = []
             
             for i in range(num_masks):
@@ -360,7 +349,6 @@ def create_sam_mask(self, image, bbox_coords, mode):
                 mask_np = resized_mask.sigmoid().cpu().numpy()
                 all_masks.append(mask_np)
 
-                
             # BBox-Information für Heuristik
             bbox_center = ((x1 + x2) // 2, (y1 + y2) // 2)
             bbox_area = (x2 - x1) * (y2 - y1)
@@ -450,7 +438,6 @@ def create_sam_mask(self, image, bbox_coords, mode):
             mask_np = resized_mask.sigmoid().cpu().numpy()
             print(f"   🔄 Beste Maske skaliert auf 512×512 für ControlNet")
             
-            
             # ============================================================
             # DYNAMISCHER THRESHOLD 
             # SAM gibt nur Wahrscheinlichkeiten aus!
@@ -470,7 +457,6 @@ def create_sam_mask(self, image, bbox_coords, mode):
             # Binärmaske erstellen (256x256)
             mask_array = (mask_np > dynamic_threshold).astype(np.uint8) * 255
 
-            
             # Fallback bei leerer Maske, der höchste Wert ist 0 also schwarz
             if mask_array.max() == 0:
                 print("   ⚠️  Maske leer, erstelle rechteckige Fallback-Maske")
@@ -645,49 +631,50 @@ def create_sam_mask(self, image, bbox_coords, mode):
             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")
+            # ============================================================
+            # SCHRITT 5: SAM-AUSFÜHRUNG
+            # ============================================================
+            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"))
+            # 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
+            # Immer nur eine BBox verwenden (SAM 2 erwartet genau 1)
+            input_boxes = [[[x1, y1, x2, y2]]]
 
-        # 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
+            # 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
 
-        # BEIDE Punkte kombinieren
-        input_points = [[[[center_x, center_y], [face_x, face_y]]]] # ZWEI Punkte
-        input_labels = [[[1, 1]]]  # Beide sind positive Prompts
+            # 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
 
-        print(f"   🎯 SAM-Prompt: BBox [{x1},{y1},{x2},{y2}]")
-        print(f"   👁️  Punkte: Mitte ({center_x},{center_y}), Gesicht ({face_x},{face_y})")
+            # 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"
+            # 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())}")
@@ -695,7 +682,6 @@ def create_sam_mask(self, image, bbox_coords, mode):
             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)
@@ -763,7 +749,6 @@ def create_sam_mask(self, image, bbox_coords, mode):
                 
                 mask_area_pixels = np.sum(mask_binary) 
 
-
                 # ============================================================
                 #        SPEZIALHEURISTIK 
                 # ============================================================
@@ -865,39 +850,38 @@ def create_sam_mask(self, image, bbox_coords, mode):
             max_val = mask_np.max()
             print(f"🔍 Maximaler SAM-Konfidenzwert der besten Maske: {max_val:.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)")
+            # ============================================================
+            # 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}")
+            print(f"   🎯 Gesichts-Threshold: {dynamic_threshold:.3f}")
 
-                # Binärmaske erstellen
-                print("🐛 DEBUG THRESHOLD:")
-                print(f"   mask_np Min/Max: {mask_np.min():.3f}/{mask_np.max():.3f}")
-                print(f"   dynamic_threshold: {dynamic_threshold:.3f}")
+            # Binärmaske erstellen
+            print("🐛 DEBUG THRESHOLD:")
+            print(f"   mask_np Min/Max: {mask_np.min():.3f}/{mask_np.max():.3f}")
+            print(f"   dynamic_threshold: {dynamic_threshold:.3f}")
 
-                mask_array = (mask_np > dynamic_threshold).astype(np.uint8) * 255
+            mask_array = (mask_np > dynamic_threshold).astype(np.uint8) * 255
 
-                print(f"🚨 DEBUG BINÄRMASKE:")
-                print(f"   mask_array Min/Max: {mask_array.min()}/{mask_array.max()}")
-                print(f"   Weiße Pixel in mask_array: {np.sum(mask_array > 0)}")
-                print(f"   Anteil weiße Pixel: {np.sum(mask_array > 0) / mask_array.size:.1%}")
+            print(f"🚨 DEBUG BINÄRMASKE:")
+            print(f"   mask_array Min/Max: {mask_array.min()}/{mask_array.max()}")
+            print(f"   Weiße Pixel in mask_array: {np.sum(mask_array > 0)}")
+            print(f"   Anteil weiße Pixel: {np.sum(mask_array > 0) / mask_array.size:.1%}")
 
-                # Fallback wenn Maske leer
-                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}")
+            # Fallback wenn Maske leer
+            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}")
     
                 test_mask = np.zeros((image.height, image.width), dtype=np.uint8)
                 cv2.rectangle(test_mask, (x1, y1), (x2, y2), 255, -1)
@@ -905,126 +889,123 @@ def create_sam_mask(self, image, bbox_coords, mode):
                 mask_array = test_mask
                 print(f"🐛 DEBUG ERZWUNGENE MASKE: Weiße Pixel: {np.sum(mask_array > 0)}")
 
-                # Rohmaske speichern
-                raw_mask_array = mask_array.copy()
+            # Rohmaske speichern
+            raw_mask_array = mask_array.copy()
 
-                # ============================================================
-                #        POSTPROCESSING 
-                # ============================================================
+            # ============================================================
+            #        POSTPROCESSING 
+            # ============================================================
 
-                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)
         
-                    # 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")
+                # 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}")
+            # 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}")
+            # 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})")
+            # Immer die gespeicherten Crop-Koordinaten verwenden
+            if 'crop_x1' in locals() and 'crop_y1' in locals():
+                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}")
+            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}")
+            # Bild-Referenz zurücksetzen
+            image = original_image
+            print(f"   🔄 Bild-Referenz wieder auf Original gesetzt: {image.size}")
 
-                # ============================================================
-                # ABSCHLIESSENDE STATISTIK
-                # ============================================================
-
-                print("📊 FINALE MASKEN-STATISTIK")
-
-                # Weiße Pixel zählen
-                white_pixels = np.sum(mask_array > 0)
-                total_pixels = mask_array.size
-                white_ratio = white_pixels / total_pixels * 100
+            # ============================================================
+            # ABSCHLIESSENDE STATISTIK
+            # ============================================================
 
-                # Original-BBox Fläche (vor Crop)
-                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")
+            print("📊 FINALE MASKEN-STATISTIK")
 
-                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:,}")
-                print(f"   ���� GESICHTSABDECKUNG: {coverage_ratio:.1%} der ursprünglichen BBox")
+            # Weiße Pixel zählen
+            white_pixels = np.sum(mask_array > 0)
+            total_pixels = mask_array.size
+            white_ratio = white_pixels / total_pixels * 100
 
-                # 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%})")
+            # Original-BBox Fläche (vor Crop)
+            original_bbox_width = original_bbox[2] - original_bbox[0]
+            original_bbox_height = original_bbox[3] - original_bbox[1]
+            original_face_area = original_bbox_width * original_bbox_height
+            coverage_ratio = white_pixels / original_face_area if original_face_area > 0 else 0
+            print(f"   👤 GESICHTSABDECKUNG: {coverage_ratio:.1%} der ursprünglichen BBox")
 
-                #===============
-                
-                # Zurück zu PIL Image
-                mask = Image.fromarray(mask_array).convert("L")
-                raw_mask = Image.fromarray(raw_mask_array).convert("L")  
+            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:,}")
 
+            # 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}")
+            print("#" * 80)
+            print(f"✅ SAM 2 SEGMENTIERUNG ABGESCHLOSSEN")
+            print(f"📐 Finale Maskengröße: {mask.size}")
+            print(f"🎛️  Verwendeter Modus: {mode}")
 
-                print(f"👤 Crop={crop_size}×{crop_size}px, Heuristik-Score={best_score:.3f}")
-                print(f"👤 Kopfabdeckung: {coverage_ratio:.1%} der BBox")
+            print(f"👤 Crop={crop_size}×{crop_size}px, Heuristik-Score={best_score:.3f}")
+            print(f"👤 Kopfabdeckung: {coverage_ratio:.1%} der BBox")
 
-                print(f"🔍 DEBUG FINALE MASKE:")
-                print(f"   mask_array Min/Max: {mask_array.min()}/{mask_array.max()}, Typ: {mask_array.dtype}")
-                print(f"   Weiße Pixel final: {np.sum(mask_array > 0)}")
+            print(f"🔍 DEBUG FINALE MASKE:")
+            print(f"   mask_array Min/Max: {mask_array.min()}/{mask_array.max()}, Typ: {mask_array.dtype}")
+            print(f"   Weiße Pixel final: {np.sum(mask_array > 0)}")
 
-                print("#" * 80)
+            print("#" * 80)
 
-                return mask, raw_mask
+            return mask, raw_mask
                          
         # ============================================================
         # UNBEKANNTER MODUS
@@ -1047,6 +1028,4 @@ def create_sam_mask(self, image, bbox_coords, mode):
             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
-        
-        
+        return fallback_mask, fallback_mask