Update app.py

app.py

@@ -231,72 +231,152 @@ def scale_image_and_mask_together(image, mask, target_size=512):
     
     return padded_image, padded_mask, padding_info
 
-# === KORREKTE COMPOSITING-FUNKTION ===
-def composite_edited_region(original_image, inpaint_result, original_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"):
     """
-    KORREKTER COMPOSITING-WORKFLOW:
-    - Schneidet den bearbeiteten Bereich aus dem Inpaint-Ergebnis
-    - Fügt ihn nahtlos in das Originalbild ein
+    KOMPLETT KORRIGIERTER COMPOSITING-WORKFLOW für alle 3 Modi:
+    
+    1. 'environment_change': Original-Focus in bearbeitetes Bild integrieren
+    2. 'focus_change'/'face_only_change': Bearbeiteten Bereich in Originalbild integrieren
     
     Parameter:
     - original_image: Originalbild in Originalgröße
-    - inpaint_result: 512x512 Inpaint-Ergebnis
+    - inpaint_result: 512x512 Inpaint-Ergebnis MIT PADDING
     - original_mask: Originalmaske (vor Skalierung)
-    - padding_info: Skalierungsinformationen von scale_image_and_mask_together()
+    - padding_info: Skalierungsinformationen
+    - bbox_coords: [x1, y1, x2, y2] oder None
+    - mode: "environment_change", "focus_change", "face_only_change"
     
     Returns:
-    - composited_image: Finales Bild mit bearbeiteter Region
+    - composited_image: Finales Bild mit korrekt integrierter Region
     """
-    print(f"🎨 Starte korrektes Compositing...")
+    print(f"🎨 Starte Compositing für Modus: {mode}")
     
-    # 1. Extrahiere den bearbeiteten Bereich (die Veränderung) aus dem Inpaint-Ergebnis (ohne Padding)
+    # 1. PADDING ENTFERNEN (512x512 → herunterskaliertes Bild)
     x_offset = padding_info['x_offset']
     y_offset = padding_info['y_offset']
     scaled_width = padding_info['scaled_width']
     scaled_height = padding_info['scaled_height']
     
-    # Bereich im 512x512 Inpaint-Ergebnis, der dem originalen Bild entspricht
-    unpainted_region = inpaint_result.crop(
+    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}")
     
-    print(f"   Bearbeiteter Bereich extrahiert: {unpainted_region.size}")
+    # Herunterskaliertes Originalbild für spätere Verwendung
+    original_downscaled = original_image.resize(
+        (scaled_width, scaled_height), 
+        Image.Resampling.LANCZOS
+    )
     
-    # 2. Skaliere den bearbeiteten Bereich zurück auf Originalgröße .resize() ist eine Python Funktion, aus der Pillow-Bibliothek die das skaliert.
+    # 2. MODUS-SPEZIFISCHE VORBEREITUNG
+    if mode == "environment_change":
+        # ==============================================
+        # MODUS: UMWELT ÄNDERN (Focus bleibt original)
+        # ==============================================
+        print("🔄 Modus: Umwelt ändern - Original-Focus in bearbeitetes Bild integrieren")
+        
+        if bbox_coords and all(c is not None for c in bbox_coords):
+            x1, y1, x2, y2 = bbox_coords
+            
+            # BBox-Bereiche für herunterskalierte Bilder berechnen
+            scale_factor = padding_info['scale_factor']
+            bbox_downscaled = (
+                int(x1 * scale_factor),
+                int(y1 * scale_factor),
+                int(x2 * scale_factor),
+                int(y2 * scale_factor)
+            )
+            
+            # Original-Focus-Bereich ausschneiden
+            original_focus = original_downscaled.crop(bbox_downscaled)
+            
+            # Original-Focus in das bearbeitete Bild einfügen
+            # (überschreibt den bearbeiteten BBox-Bereich mit dem Original)
+            downscaled_result.paste(original_focus, bbox_downscaled[:2])
+            
+            print(f"✅ Original-Focus ({bbox_downscaled}) in bearbeitetes Bild integriert")
+        
+        # Für Compositing: Das gesamte bearbeitete Bild (jetzt mit Original-Focus) verwenden
+        edited_region_downscaled = downscaled_result
+        target_for_compositing = original_image  # Wird später überschrieben
+        
+    else:
+        # ==============================================
+        # MODUS: FOCUS oder GESICHT ÄNDERN
+        # ==============================================
+        mode_name = "Focus" if mode == "focus_change" else "Gesicht"
+        print(f"🔄 Modus: {mode_name} ändern - Bearbeiteten Bereich in Originalbild integrieren")
+        
+        if bbox_coords and all(c is not None for c in bbox_coords):
+            x1, y1, x2, y2 = bbox_coords
+            
+            # BBox-Bereich für herunterskaliertes Bild berechnen
+            scale_factor = padding_info['scale_factor']
+            bbox_downscaled = (
+                int(x1 * scale_factor),
+                int(y1 * scale_factor),
+                int(x2 * scale_factor),
+                int(y2 * scale_factor)
+            )
+            
+            # Bearbeiteten BBox-Bereich ausschneiden
+            edited_region_downscaled = downscaled_result.crop(bbox_downscaled)
+            print(f"✅ Bearbeiteten {mode_name}-Bereich ausgeschnitten: {bbox_downscaled}")
+        else:
+            # Fallback: gesamtes Bild verwenden
+            edited_region_downscaled = downscaled_result
+        
+        target_for_compositing = original_image
+    
+    # 3. HOCHSKALIEREN auf Originalgröße
     original_size = (padding_info['original_width'], padding_info['original_height'])
-    edited_region_fullsize = unpainted_region.resize(original_size, Image.Resampling.LANCZOS)
     
-    print(f"   Auf Originalgröße skaliert: {edited_region_fullsize.size}")
+    if mode == "environment_change":
+        # Das gesamte bearbeitete Bild (mit Original-Focus) hochskalieren
+        edited_region_fullsize = edited_region_downscaled.resize(
+            original_size, 
+            Image.Resampling.LANCZOS
+        )
+        print(f"✅ Komplettes Bild auf Originalgröße skaliert: {edited_region_fullsize.size}")
+        
+        # Bei environment_change ist das Ergebnis bereits komplett
+        return edited_region_fullsize.convert("RGB")
     
-    # 3. Erstelle eine weiche Maske für nahtloses Einfügen
-    # Erweitere die Originalmaske leicht für weiche Übergänge
-    # Dieser gesamte Codeblock erzeugt weiche Übergänge, damit der bearbeitete Bereich nicht wie eine harte, ausgeschnittene "Collage" im Originalbild aussieht. Die Kombination aus MaxFilter (erweitert die Maske) und GaussianBlur (verwischt die Kante) erzeugt eine weiche Alpha-Maske für sanftes Alpha Blending.
-    soft_mask = original_mask.copy()
+    else:
+        # Nur den bearbeiteten BBox-Bereich hochskalieren
+        edited_region_fullsize = edited_region_downscaled.resize(
+            original_size,
+            Image.Resampling.LANCZOS
+        )
+        print(f"✅ Bearbeiteter Bereich auf Originalgröße skaliert: {edited_region_fullsize.size}")
     
-    # Für weiche Kanten: Erweitere die Maske um 5 Pixel
+    # 4. COMPOSITING mit weicher Maske (nur für focus_change/face_only_change)
+    # Weiche Maske erstellen für sanfte Übergänge
     from PIL import ImageFilter
-    soft_mask = soft_mask.filter(ImageFilter.MaxFilter(5))
-    soft_mask = soft_mask.filter(ImageFilter.GaussianBlur(3))
     
-    # 4. Compositing: Kombiniere Originalbild und bearbeiteten Bereich
-    final_image = original_image.copy()
+    soft_mask = original_mask.copy()
+    soft_mask = soft_mask.filter(ImageFilter.MaxFilter(5))  # Maske leicht erweitern
+    soft_mask = soft_mask.filter(ImageFilter.GaussianBlur(3))  # Weiche Kanten
     
-    # Konvertiere für alpha blending
+    # Alpha-Blending vorbereiten
+    final_image = original_image.copy()
     edited_rgba = edited_region_fullsize.convert("RGBA")
     soft_mask_rgba = soft_mask.convert("L")
     
-    # Erstelle ein temporäres Bild mit Alpha-Kanal
+    # Temporäres Bild mit Alpha-Kanal
     temp_image = Image.new("RGBA", original_size, (0, 0, 0, 0))
     temp_image.paste(edited_rgba, (0, 0), soft_mask_rgba)
     
-    # Kombiniere mit Original
+    # Finales Compositing
     final_image = Image.alpha_composite(final_image.convert("RGBA"), temp_image)
     final_image = final_image.convert("RGB")
     
     print(f"✅ Compositing abgeschlossen. Finale Größe: {final_image.size}")
-    
     return final_image
 
+
 def auto_detect_face_area(image):
     """Optimierten Vorschlag für Gesichtsbereich ohne externe Bibliotheken"""
     width, height = image.size
@@ -1045,8 +1125,10 @@ def img_to_image(image, prompt, neg_prompt, strength, steps, guidance_scale,
                 original_image=image.convert("RGB"),
                 inpaint_result=generated_image,
                 original_mask=original_mask,
-                padding_info=padding_info
-            )
+                padding_info=padding_info,
+                bbox_coords=(bbox_x1, bbox_y1, bbox_x2, bbox_y2),  # NEU!
+                mode=mode  # NEU!
+            )            
             print(f"✅ Korrektes Compositing durchgeführt")
         else:
             # Keine Maske: Einfach das generierte Bild zurückgeben