Update app.py

app.py

@@ -235,151 +235,152 @@ 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"):
     """
-    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 MIT PADDING
-    - original_mask: Originalmaske (vor Skalierung)
-    - 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 korrekt integrierter Region
+    OPTIMIERTER COMPOSITING-WORKFLOW für alle Bildgrößen
     """
     print(f"🎨 Starte Compositing für Modus: {mode}")
+    print(f"📏 Originalgröße: {original_image.size}")
+    print(f"📏 Inpaint-Result-Größe: {inpaint_result.size}")
     
-    # 1. PADDING ENTFERNEN (512x512 → herunterskaliertes Bild)
+    # Extrahiere Padding-Info
     x_offset = padding_info['x_offset']
     y_offset = padding_info['y_offset']
     scaled_width = padding_info['scaled_width']
     scaled_height = padding_info['scaled_height']
-    
+    scale_factor = padding_info['scale_factor']
+    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
+    # ==============================================
+    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}")
+        return inpaint_result
+    
+    # ==============================================
+    # FALL 2 & 3: Bild wurde skaliert (größer/kleiner als 512×512)
+    # ==============================================
+    print(f"🔄 FALL 2/3: Bild skaliert - Compositing Workflow")
+    
+    # 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}")
     
-    # Herunterskaliertes Originalbild für spätere Verwendung
-    original_downscaled = original_image.resize(
-        (scaled_width, scaled_height), 
-        Image.Resampling.LANCZOS
-    )
+    # 2. MODUS-SPEZIFISCHE LOGIK
+    original_size = (original_width, original_height)
     
-    # 2. MODUS-SPEZIFISCHE VORBEREITUNG
     if mode == "environment_change":
         # ==============================================
         # MODUS: UMWELT ÄNDERN (Focus bleibt original)
         # ==============================================
-        print("🔄 Modus: Umwelt ändern - Original-Focus in bearbeitetes Bild integrieren")
+        print("🌳 Modus: Umwelt ändern")
+        
+        # Gesamtes bearbeitetes Bild hochskalieren
+        final_image = downscaled_result.resize(original_size, 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
             
-            # BBox-Bereiche für herunterskalierte Bilder berechnen
-            scale_factor = padding_info['scale_factor']
-            bbox_downscaled = (
+            # Skalierte BBox berechnen
+            bbox_scaled = (
                 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 ausschneiden (von original_downscaled)
+            original_downscaled = original_image.resize(
+                (scaled_width, scaled_height), 
+                Image.Resampling.LANCZOS
+            )
+            original_focus = original_downscaled.crop(bbox_scaled)
             
-            # Original-Focus in das bearbeitete Bild einfügen
-            # (überschreibt den bearbeiteten BBox-Bereich mit dem Original)
-            downscaled_result.paste(original_focus, bbox_downscaled[:2])
+            # Focus auf Originalgröße skalieren
+            focus_original_size = (x2 - x1, y2 - y1)
+            original_focus_fullsize = original_focus.resize(
+                focus_original_size, 
+                Image.Resampling.LANCZOS
+            )
             
-            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
+            # In finales Bild einfügen
+            final_image.paste(original_focus_fullsize, (x1, y1))
+            print(f"✅ Original-Focus eingefügt: {bbox_scaled} → {x1},{y1}")
         
+        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 - Bearbeiteten Bereich in Originalbild integrieren")
+        print(f"👤 Modus: {mode_name} ändern")
         
-        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
+        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")
+            return final_image.convert("RGB")
         
-        target_for_compositing = original_image
-    
-    # 3. HOCHSKALIEREN auf Originalgröße
-    original_size = (padding_info['original_width'], padding_info['original_height'])
-    
-    if mode == "environment_change":
-        # Das gesamte bearbeitete Bild (mit Original-Focus) hochskalieren
-        edited_region_fullsize = edited_region_downscaled.resize(
-            original_size, 
-            Image.Resampling.LANCZOS
+        x1, y1, x2, y2 = bbox_coords
+        
+        # Skalierte BBox für downscaled_result
+        bbox_scaled = (
+            int(x1 * scale_factor),
+            int(y1 * scale_factor), 
+            int(x2 * scale_factor),
+            int(y2 * scale_factor)
         )
-        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")
-    
-    else:
-        # Nur den bearbeiteten BBox-Bereich hochskalieren
-        edited_region_fullsize = edited_region_downscaled.resize(
-            original_size,
+        # 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
         )
-        print(f"✅ Bearbeiteter Bereich auf Originalgröße skaliert: {edited_region_fullsize.size}")
-    
-    # 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 = original_mask.copy()
-    soft_mask = soft_mask.filter(ImageFilter.MaxFilter(5))  # Maske leicht erweitern
-    soft_mask = soft_mask.filter(ImageFilter.GaussianBlur(3))  # Weiche Kanten
-    
-    # Alpha-Blending vorbereiten
-    final_image = original_image.copy()
-    edited_rgba = edited_region_fullsize.convert("RGBA")
-    soft_mask_rgba = soft_mask.convert("L")
-    
-    # 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)
-    
-    # Finales Compositing
-    final_image = Image.alpha_composite(final_image.convert("RGBA"), temp_image)
-    final_image = final_image.convert("RGB")
+        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")
     
-    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"""