Update controlnet_module.py

controlnet_module.py

@@ -104,8 +104,8 @@ class ControlNetProcessor:
 
     def create_sam_mask(self, image, bbox_coords, mode):
         """
-        Erstellt präzise Maske mit SAM 2 und Nachbearbeitung
-        Gibt PIL Image in L-Modus zurück (0=schwarz=erhalten, 255=weiß=verändern)
+        ERWEITERTE Funktion: Erstellt präzise Maske mit SAM 2
+        Sonderbehandlung für face_only_change: Arbeitet auf Bildausschnitt
         """
         try:
             print("#" * 80)
@@ -127,10 +127,62 @@ class ControlNetProcessor:
 
             # 2. Validiere BBox
             x1, y1, x2, y2 = self._validate_bbox(image, bbox_coords)
+            
+            # ============================================================
+            # SPEZIALBEHANDLUNG NUR FÜR face_only_change
+            # ============================================================
+            if mode == "face_only_change":
+                print("-" * 60)
+                print("👤 SPEZIALMODUS: NUR GESICHT - ERSTELLE FOKUSIERTEN AUSSCHNITT")
+                print("-" * 60)
+                
+                # Originalbild und Koordinaten sichern
+                original_image = image
+                original_bbox = (x1, y1, x2, y2)
+                
+                # Puffer um die BBox berechnen (20% der BBox-Größe, mindestens 50px)
+                padding_x = max(50, int((x2 - x1) * 0.2))
+                padding_y = max(50, int((y2 - y1) * 0.2))
+                
+                # Ausschnitt-Koordinaten berechnen (innerhalb der Bildgrenzen)
+                crop_x1 = max(0, x1 - padding_x)
+                crop_y1 = max(0, y1 - padding_y)
+                crop_x2 = min(image.width, x2 + padding_x)
+                crop_y2 = min(image.height, y2 + padding_y)
+                
+                print(f"   📐 Original-BBox: [{x1}, {y1}, {x2}, {y2}]")
+                print(f"   📏 Original-BBox Größe: {x2-x1} × {y2-y1} px")
+                print(f"   🔲 Ausschnitt-Bereich: [{crop_x1}, {crop_y1}, {crop_x2}, {crop_y2}]")
+                print(f"   📏 Ausschnitt-Größe: {crop_x2-crop_x1} × {crop_y2-crop_y1} px")
+                print(f"   📊 Puffer: {padding_x} × {padding_y} px")
+                
+                # Bild ausschneiden
+                cropped_image = image.crop((crop_x1, crop_y1, crop_x2, crop_y2))
+                print(f"   ✅ Ausschnitt erstellt: {cropped_image.size}")
+                
+                # BBox-Koordinaten relativ zum Ausschnitt neu berechnen
+                rel_x1 = x1 - crop_x1
+                rel_y1 = y1 - crop_y1
+                rel_x2 = x2 - crop_x1
+                rel_y2 = y2 - crop_y1
+                
+                print(f"   🎯 Relative BBox im Ausschnitt: [{rel_x1}, {rel_y1}, {rel_x2}, {rel_y2}]")
+                print(f"   📏 Relative BBox Größe: {rel_x2-rel_x1} × {rel_y2-rel_y1} px")
+                
+                # Für SAM: Verwende Ausschnitt und relative Koordinaten
+                image = cropped_image
+                x1, y1, x2, y2 = rel_x1, rel_y1, rel_x2, rel_y2
+                
+                print("   🔄 SAM wird auf Ausschnitt (nicht Vollbild) ausgeführt")
+            
+            # ============================================================
+            # GEMEINSAME SAM-LOGIK FÜR ALLE MODI
+            # (arbeitet auf `image` - bei face_only_change ist das der Ausschnitt)
+            # ============================================================
             print("-" * 60)
-            print(f"📦 BOUNDING BOX DETAILS:")
-            print(f"   Ursprüngliche Koordinaten: {bbox_coords}")
-            print(f"   Validierte Koordinaten: [{x1}, {y1}, {x2}, {y2}]")
+            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
@@ -174,7 +226,8 @@ class ControlNetProcessor:
             print(f"   Nach Sigmoid und CPU: {mask_np.shape}, Wertebereich: [{mask_np.min():.3f}, {mask_np.max():.3f}]")
             
             mask_array = (mask_np > 0.5).astype(np.uint8) * 255
-            print(f"   Nach Threshold (0.5): {mask_array.shape}, Unique Werte: {np.unique(mask_array)}")
+            unique_vals = np.unique(mask_array)
+            print(f"   Nach Threshold (0.5): {mask_array.shape}, Unique Werte: {unique_vals}")
 
             # 7. BEIDE MASKEN ERSTELLEN (vor Nachbearbeitung)
             original_mask_array = mask_array.copy()        # Person weiß (255), Hintergrund schwarz (0)
@@ -253,21 +306,28 @@ class ControlNetProcessor:
                 print("   ✅ Focus-Modus: Person verändert, Hintergrund geschützt")
                 
             elif mode == "face_only_change":
-                print("👤 MODUS: NUR GESICHT ÄNDERN")
+                print("👤 MODUS: NUR GESICHT ÄNDERN (AUF AUSSCHNITT)")
                 # Arbeite auf der ORIGINAL-Maske (Person weiß, Hintergrund schwarz)
                 mask_array = original_mask_array.copy()
                 print("   Arbeite auf originaler Maske (Person weiß, Hintergrund schwarz)")
                 
                 # Größte weiße Komponente behalten (Person)
                 labeled_array, num_features = ndimage.label(mask_array)
-                print(f"   Gefundene weiße Komponenten (Person): {num_features}")
+                print(f"   Gefundene weiße Komponenten auf AUSSCHNITT: {num_features}")
                 
-                if num_features > 1:
+                if num_features > 0:
                     sizes = ndimage.sum(mask_array, labeled_array, range(1, num_features + 1))
-                    print(f"   Größen der weißen Komponenten: {sizes}")
-                    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} Komponenten)")
+                    print(f"   Größen der weißen Komponenten auf AUSSCHNITT: {sizes}")
+                    
+                    if num_features > 1:
+                        # WICHTIG: Für Gesicht nehmen wir die GRÖSSTE Komponente im AUSSCHNITT
+                        # (Im Ausschnitt sollte das das Gesicht sein, nicht der Hintergrund)
+                        largest_component = np.argmax(sizes) + 1
+                        mask_array = np.where(labeled_array == largest_component, mask_array, 0)
+                        print(f"   ✅ Behalte größte Komponente im Ausschnitt ({num_features} Komponenten)")
+                        print(f"   📊 Größe der behaltenen Komponente: {sizes[largest_component-1]:,} Pixel")
+                    else:
+                        print(f"   ℹ️ Nur eine Komponente gefunden, behalte diese")
                 
                 # Starke Erosion für präzises Gesicht
                 kernel = np.ones((3,3), np.uint8)
@@ -282,7 +342,33 @@ class ControlNetProcessor:
                 print(f"   Wende GaussianBlur an (Kernel 3x3) für glatte Kanten...")
                 mask_array = cv2.GaussianBlur(mask_array, (3, 3), 0)
                 
-                print("   ✅ Gesichts-Modus: Nur Gesicht verändert")
+                print("   ✅ Gesichts-Modus: Nachbearbeitung auf Ausschnitt abgeschlossen")
+                
+                # ============================================================
+                # SPEZIALSCHRITT NUR FÜR face_only_change: MASKE ZURÜCKSKALIEREN
+                # ============================================================
+                print("-" * 60)
+                print("🔄 SPEZIALSCHRITT: MASKE VOM AUSSCHNITT ZURÜCK AUF ORIGINALGRÖSSE")
+                
+                # Temporäre Maske aus dem Array erstellen
+                temp_mask = Image.fromarray(mask_array).convert("L")
+                print(f"   Maskengröße auf Ausschnitt: {temp_mask.size}")
+                
+                # Leere Maske in Originalbild-Größe erstellen
+                final_mask = Image.new("L", original_image.size, 0)
+                print(f"   Leere Maske in Originalgröße: {final_mask.size}")
+                
+                # Die segmentierte Maske an der richtigen Position im Originalbild platzieren
+                final_mask.paste(temp_mask, (crop_x1, crop_y1))
+                print(f"   Maskenposition im Original: ({crop_x1}, {crop_y1})")
+                
+                # Zurück zum mask_array konvertieren
+                mask_array = np.array(final_mask)
+                print(f"   ✅ Maske zurück auf Originalgröße skaliert: {mask_array.shape}")
+                
+                # Originalbild wiederherstellen für eventuelle spätere Verwendung
+                image = original_image
+                print(f"   🔄 Bild-Referenz wieder auf Original gesetzt: {image.size}")
 
             # 9. Qualitätskontrolle und Statistik
             white_pixels = np.sum(mask_array > 127)
@@ -303,6 +389,7 @@ class ControlNetProcessor:
             print("#" * 80)
             print(f"✅ SAM 2 SEGMENTIERUNG ABGESCHLOSSEN")
             print(f"📐 Finale Maskengröße: {mask.size}")
+            print(f"🎛️  Verwendeter Modus: {mode}")
             print("#" * 80)
             return mask