Update app.py

app.py

@@ -236,14 +236,16 @@ def scale_image_and_mask_together(image, mask, target_size=512):
     return padded_image, padded_mask, padding_info
 
 
+
+
 # Composition Workflow nach Ausgabe ControlnetInpaint-Pipeline
-def composite_edited_region(original_image, inpaint_result, original_mask, padding_info, bbox_coords=None, mode="environment_change"):
+def enhanced_composite_with_sam(original_image, inpaint_result, original_mask, 
+                                padding_info, bbox_coords, mode):
     """
-    OPTIMIERTER COMPOSITING-WORKFLOW für alle Bildgrößen
+    VERBESSERTES COMPOSITING MIT SAM-MASKEN
+    Berücksichtigt die präzisen Kanten der SAM-Maske
     """
-    print(f"🎨 Starte Compositing für Modus: {mode}")
-    print(f"📏 Originalgröße: {original_image.size}")
-    print(f"📏 Inpaint-Result-Größe: {inpaint_result.size}")
+    print(f"🎨 Verbessertes Compositing für Modus: {mode}")
     
     # Extrahiere Padding-Info
     x_offset = padding_info['x_offset']
@@ -254,94 +256,69 @@ def composite_edited_region(original_image, inpaint_result, original_mask, paddi
     original_width = padding_info['original_width']
     original_height = padding_info['original_height']
     
-    print(f"📊 Skalierungsfaktor: {scale_factor:.4f}")
-    print(f"📊 Offsets: x={x_offset}, y={y_offset}")
-    print(f"📊 Skalierte Größe: {scaled_width}x{scaled_height}")
-    
-    if bbox_coords:
-        print(f"🎯 BBox Original: {bbox_coords}")
-    
     # ==============================================
-    # FALL 1: Bild war bereits 512×512 (keine Skalierung, kein Padding)
-    # ControlNet-Inpaint hat bereits komplettes Bild bearbeitet
+    # FALL 1: Bild war bereits 512×512 (keine Skalierung)
     # ==============================================
     if scale_factor == 1.0 and x_offset == 0 and y_offset == 0:
-        print(f"✅ FALL 1: Bild 512×512 - direktes ControlNet-Inpaint Result")
-        print(f"   Kein Compositing nötig für {mode}")
+        print(f"✅ FALL 1: Bild 512×512 - kein Compositing nötig")
         return inpaint_result
     
     # ==============================================
-    # FALL 2 & 3: Bild wurde skaliert (größer/kleiner als 512×512)
+    # FALL 2 & 3: Bild wurde skaliert
     # ==============================================
-    print(f"🔄 FALL 2/3: Bild skaliert - Compositing Workflow")
+    print(f"🔄 FALL 2/3: Bild skaliert - Compositing mit SAM-Maske")
     
     # 1. PADDING ENTFERNEN von 512×512 Ergebnis
     downscaled_result = inpaint_result.crop(
         (x_offset, y_offset, x_offset + scaled_width, y_offset + scaled_height)
     )
-    print(f"✅ Padding entfernt: {inpaint_result.size} → {downscaled_result.size}")
     
-    # 2. MODUS-SPEZIFISCHE LOGIK
-    original_size = (original_width, original_height)
+    # 2. AUF ORIGINALGRÖßE SKALIEREN
+    final_image = original_image.copy()
     
     if mode == "environment_change":
         # ==============================================
-        # MODUS: UMWELT ÄNDERN (Focus bleibt original)
+        # MODUS: UMWELT ÄNDERN (Objekt bleibt original)
         # ==============================================
-        print("🌳 Modus: Umwelt ändern")
+        print("🌳 Modus: Umwelt ändern mit SAM-Maske")
         
         # Gesamtes bearbeitetes Bild hochskalieren
-        final_image = downscaled_result.resize(original_size, Image.Resampling.LANCZOS)
+        new_background = downscaled_result.resize(
+            (original_width, original_height), 
+            Image.Resampling.LANCZOS
+        )
         
-        # Original-Focus zurück einfügen
-        if bbox_coords and all(c is not None for c in bbox_coords):
-            x1, y1, x2, y2 = bbox_coords
-            
-            # Skalierte BBox berechnen
-            bbox_scaled = (
-                int(x1 * scale_factor),
-                int(y1 * scale_factor),
-                int(x2 * scale_factor),
-                int(y2 * scale_factor)
-            )
-            
-            # Original-Focus ausschneiden (von original_downscaled)
-            original_downscaled = original_image.resize(
-                (scaled_width, scaled_height), 
-                Image.Resampling.LANCZOS
-            )
-            original_focus = original_downscaled.crop(bbox_scaled)
-            
-            # Focus auf Originalgröße skalieren
-            focus_original_size = (x2 - x1, y2 - y1)
-            original_focus_fullsize = original_focus.resize(
-                focus_original_size, 
-                Image.Resampling.LANCZOS
-            )
-            
-            # In finales Bild einfügen
-            final_image.paste(original_focus_fullsize, (x1, y1))
-            print(f"✅ Original-Focus eingefügt: {bbox_scaled} → {x1},{y1}")
+        # Originalbild mit SAM-Maske einfügen
+        original_with_alpha = original_image.copy().convert("RGBA")
+        
+        # Invertierte Maske für Objekterhalt
+        mask_inverted = Image.eval(original_mask, lambda x: 255 - x)
+        
+        # Weiche Kanten für natürlichen Übergang
+        soft_mask = mask_inverted.filter(ImageFilter.GaussianBlur(3))
+        original_with_alpha.putalpha(soft_mask)
+        
+        # Compositing
+        final_image = new_background.copy().convert("RGBA")
+        final_image.paste(original_with_alpha, (0, 0), original_with_alpha)
         
-        print(f"✅ Finales Bild: {final_image.size}")
-        return final_image.convert("RGB")
-    
     else:
         # ==============================================
         # MODUS: FOCUS oder GESICHT ÄNDERN
         # ==============================================
         mode_name = "Focus" if mode == "focus_change" else "Gesicht"
-        print(f"👤 Modus: {mode_name} ändern")
+        print(f"👤 Modus: {mode_name} ändern mit SAM-Maske")
         
         if not bbox_coords or not all(c is not None for c in bbox_coords):
             # Keine BBox: gesamtes Bild zurückgeben
-            final_image = downscaled_result.resize(original_size, Image.Resampling.LANCZOS)
-            print(f"⚠️ Keine BBox - gesamtes Bild skaliert")
+            final_image = downscaled_result.resize(
+                (original_width, original_height), 
+                Image.Resampling.LANCZOS
+            )
             return final_image.convert("RGB")
         
+        # Bearbeiteten Bereich ausschneiden und hochskalieren
         x1, y1, x2, y2 = bbox_coords
-        
-        # Skalierte BBox für downscaled_result
         bbox_scaled = (
             int(x1 * scale_factor),
             int(y1 * scale_factor), 
@@ -349,38 +326,59 @@ def composite_edited_region(original_image, inpaint_result, original_mask, paddi
             int(y2 * scale_factor)
         )
         
-        # Bearbeiteten Bereich ausschneiden
-        edited_region = downscaled_result.crop(bbox_scaled)
-        print(f"✅ Bearbeiteter Bereich: {bbox_scaled} → {edited_region.size}")
-        
-        # Auf ORIGINAL-BBox-Größe skalieren (nicht Gesamtbild!)
-        original_bbox_size = (x2 - x1, y2 - y1)
-        edited_region_fullsize = edited_region.resize(
-            original_bbox_size, 
-            Image.Resampling.LANCZOS
+        # Sicherstellen, dass BBox gültig ist
+        bbox_scaled = (
+            max(0, bbox_scaled[0]),
+            max(0, bbox_scaled[1]),
+            min(scaled_width, bbox_scaled[2]),
+            min(scaled_height, bbox_scaled[3])
         )
-        print(f"✅ Auf BBox-Größe skaliert: {edited_region.size} → {edited_region_fullsize.size}")
-        
-        # 3. COMPOSITING mit weicher Maske
-        from PIL import ImageFilter
         
-        # Maske zuschneiden und weichzeichnen
-        mask_cropped = original_mask.crop((x1, y1, x2, y2))
-        soft_mask = mask_cropped.filter(ImageFilter.GaussianBlur(3))
-        
-        # Alpha-Compositing
-        final_image = original_image.copy()
-        edited_rgba = edited_region_fullsize.convert("RGBA")
-        mask_rgba = soft_mask.convert("L")
-        
-        temp_image = Image.new("RGBA", original_bbox_size, (0, 0, 0, 0))
-        temp_image.paste(edited_rgba, (0, 0), mask_rgba)
-        
-        final_image.paste(temp_image, (x1, y1), temp_image)
-        
-        print(f"✅ Compositing abgeschlossen. Finale Größe: {final_image.size}")
-        return final_image.convert("RGB")
+        if bbox_scaled[2] > bbox_scaled[0] and bbox_scaled[3] > bbox_scaled[1]:
+            edited_region = downscaled_result.crop(bbox_scaled)
+            
+            # Auf ORIGINAL-BBox-Größe skalieren
+            original_bbox_size = (x2 - x1, y2 - y1)
+            edited_region_fullsize = edited_region.resize(
+                original_bbox_size, 
+                Image.Resampling.LANCZOS
+            )
+            
+            # SAM-Maske für den Bereich zuschneiden und weichzeichnen
+            mask_cropped = original_mask.crop((x1, y1, x2, y2))
+            soft_mask = mask_cropped.filter(ImageFilter.GaussianBlur(3))
+            
+            # Alpha-Compositing mit präziser SAM-Maske
+            edited_rgba = edited_region_fullsize.convert("RGBA")
+            mask_rgba = soft_mask.convert("L")
+            
+            temp_image = Image.new("RGBA", original_bbox_size, (0, 0, 0, 0))
+            temp_image.paste(edited_rgba, (0, 0), mask_rgba)
+            
+            final_image.paste(temp_image, (x1, y1), temp_image)
     
+    print(f"✅ Verbessertes Compositing abgeschlossen. Finale Größe: {final_image.size}")
+    return final_image.convert("RGB")
+
+
+# Und in der img_to_image() Funktion ersetzen Sie das Compositing:
+# Statt:
+# final_image = composite_edited_region(...)
+
+# Verwenden Sie:
+if original_mask is not None and padding_info is not None:
+    # Verbessertes Compositing mit SAM-Masken
+    final_image = enhanced_composite_with_sam(
+        original_image=image.convert("RGB"),
+        inpaint_result=generated_image,
+        original_mask=original_mask,
+        padding_info=padding_info,
+        bbox_coords=(bbox_x1, bbox_y1, bbox_x2, bbox_y2),
+        mode=mode
+    )
+
+
+
 
 def auto_detect_face_area(image):
     """Optimierten Vorschlag für Gesichtsbereich ohne externe Bibliotheken"""