Update app.py

app.py

@@ -245,6 +245,198 @@ def scale_image_and_mask_together(image, mask, target_size=512, bbox_coords=None
 
 
 
+def enhanced_composite_with_sam(original_image, inpaint_result, original_mask, 
+                                padding_info, bbox_coords, mode):
+    """
+    COMPOSITING MIT SAM-MASKEN (MASKE-BASIERT)
+    Berücksichtigt die präzisen/erweiterten Kanten der SAM-Maske
+    """
+    print(f"🎨 Verbessertes Compositing für Modus: {mode}")
+    
+    # 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']
+    
+    # ==============================================
+    # 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 - einfaches Compositing")
+        
+        if mode == "environment_change":
+            # Umgebung ändern: SAM-Maske invertieren (Objekt schützen)
+            mask_inverted = Image.eval(original_mask, lambda x: 255 - x)
+            soft_mask = mask_inverted.filter(ImageFilter.GaussianBlur(5))
+            
+            original_with_alpha = original_image.copy().convert("RGBA")
+            original_with_alpha.putalpha(soft_mask)
+            
+            final_image = inpaint_result.copy().convert("RGBA")
+            final_image.paste(original_with_alpha, (0, 0), original_with_alpha)
+            return final_image.convert("RGB")
+        
+        else:
+            # Focus/Face: Direktes Alpha-Compositing
+            soft_mask = original_mask.filter(ImageFilter.GaussianBlur(5))
+            
+            inpaint_rgba = inpaint_result.convert("RGBA")
+            mask_alpha = soft_mask.convert("L")
+            inpaint_rgba.putalpha(mask_alpha)
+            
+            original_rgba = original_image.convert("RGBA")
+            
+            # Composite
+            final_image = Image.new("RGBA", original_image.size, (0, 0, 0, 0))
+            final_image.paste(original_rgba, (0, 0))
+            final_image.paste(inpaint_rgba, (0, 0), inpaint_rgba)
+            return final_image.convert("RGB")
+    
+    # ==============================================
+    # FALL 2 & 3: Bild wurde skaliert - MASKE-BASIERTES COMPOSITING
+    # ==============================================
+    print(f"🔄 FALL 2/3: Bild skaliert - MASKE-BASIERTES COMPOSITING")
+    
+    # 1. PADDING ENTFERNEN von 512×512 Ergebnis
+    downscaled_result = inpaint_result.crop(
+        (x_offset, y_offset, x_offset + scaled_width, y_offset + scaled_height)
+    )
+    
+    # 2. AUF ORIGINALGRÖßE SKALIEREN (Bearbeitetes Bild)
+    new_background = downscaled_result.resize(
+        (original_width, original_height), 
+        Image.Resampling.LANCZOS
+    )
+    
+    # 3. SAM-MASKE FÜR KOMPOSITING VORBEREITEN
+    print(f"📐 SAM-Maske Größe: {original_mask.size}")
+    
+    if mode == "environment_change":
+        # ==============================================
+        # MODUS: UMWELT ÄNDERN (Objekt bleibt original)
+        # ==============================================
+        print("🌳 Modus: Umwelt ändern mit SAM-Maske")
+        
+        # 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(5))
+        
+        # Originalbild mit Alpha-Kanal
+        original_with_alpha = original_image.copy().convert("RGBA")
+        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"✅ Umwelt-Compositing abgeschlossen")
+        
+    else:
+        # ==============================================
+        # MODUS: FOCUS oder GESICHT ÄNDERN (MASKE-BASIERT)
+        # ==============================================
+        mode_name = "Focus" if mode == "focus_change" else "Gesicht"
+        print(f"👤 Modus: {mode_name} ändern - MASKE-BASIERT")
+        
+        # WICHTIG: MASKE-BASIERTES AUSSCHNEIDEN
+        # 3a. SAM-Maske auf 512px skalieren
+        mask_on_512 = original_mask.resize((512, 512), Image.Resampling.LANCZOS)
+        
+        # 3b. Bounding Box der Maske auf 512px finden
+        mask_array = np.array(mask_on_512)
+        white_pixels = np.where(mask_array > 128)
+        
+        if len(white_pixels[0]) == 0:
+            print("⚠️  Keine weißen Pixel in Maske → Fallback auf BBox")
+            if bbox_coords and all(c is not None for c in bbox_coords):
+                # Fallback: User-BBox verwenden
+                mask_bbox_512 = (
+                    int(bbox_coords[0] * scale_factor) + x_offset,
+                    int(bbox_coords[1] * scale_factor) + y_offset,
+                    int(bbox_coords[2] * scale_factor) + x_offset,
+                    int(bbox_coords[3] * scale_factor) + y_offset
+                )
+            else:
+                # Keine BBox → gesamtes Bild
+                final_image = new_background
+                return final_image.convert("RGB")
+        else:
+            # MASKE-BASIERTE BBOX berechnen
+            y_min, x_min = white_pixels[0].min(), white_pixels[1].min()
+            y_max, x_max = white_pixels[0].max(), white_pixels[1].max()
+            
+            # Puffer für bessere Ergebnisse
+            buffer = 15
+            x_min = max(0, x_min - buffer)
+            y_min = max(0, y_min - buffer)
+            x_max = min(512, x_max + buffer)
+            y_max = min(512, y_max + buffer)
+            
+            mask_bbox_512 = (x_min, y_min, x_max, y_max)
+            
+            print(f"   🎯 Maske-basierte BBox auf 512px: {mask_bbox_512}")
+            print(f"   📏 Größe: {x_max-x_min}×{y_max-y_min} Pixel")
+        
+        # 3c. Bearbeiteten Bereich aus 512×512 ausschneiden (MASKE-BASIERT)
+        edited_region_512 = inpaint_result.crop(mask_bbox_512)
+        
+        # 3d. Auf Original-Maskengröße skalieren
+        mask_width = mask_bbox_512[2] - mask_bbox_512[0]
+        mask_height = mask_bbox_512[3] - mask_bbox_512[1]
+        
+        # Maske auf Ausschnitt-Größe zuschneiden
+        mask_cropped = mask_on_512.crop(mask_bbox_512)
+        
+        # Auf Originalgröße skalieren (mit Maske als Alpha)
+        mask_original_cropped = mask_cropped.resize(
+            (original_width, original_height),
+            Image.Resampling.LANCZOS
+        )
+        
+        edited_region_fullsize = edited_region_512.resize(
+            (original_width, original_height),
+            Image.Resampling.LANCZOS
+        )
+        
+        # 3e. Weiche Kanten für natürliche Übergänge
+        soft_mask = mask_original_cropped.filter(ImageFilter.GaussianBlur(5))
+        
+        # 3f. Alpha-Compositing
+        edited_rgba = edited_region_fullsize.convert("RGBA")
+        edited_rgba.putalpha(soft_mask)
+        
+        # 3g. MASKE-BASIERTE POSITION bestimmen
+        # BBox der Maske im Originalbild finden
+        mask_original_array = np.array(original_mask)
+        white_original = np.where(mask_original_array > 128)
+        
+        if len(white_original[0]) > 0:
+            paste_x = white_original[1].min()
+            paste_y = white_original[0].min()
+            print(f"   📍 Einfüge-Position (maske-basiert): ({paste_x}, {paste_y})")
+        else:
+            # Fallback: Zentriert
+            paste_x = (original_width - edited_rgba.width) // 2
+            paste_y = (original_height - edited_rgba.height) // 2
+            print(f"   📍 Einfüge-Position (zentriert): ({paste_x}, {paste_y})")
+        
+        # 3h. Finales Compositing
+        final_image = original_image.copy().convert("RGBA")
+        final_image.paste(edited_rgba, (paste_x, paste_y), edited_rgba)
+        
+        print(f"   ✅ {mode_name}-Compositing maskenbasiert abgeschlossen")
+    
+    print(f"✅ Korrektes Compositing abgeschlossen. Finale Größe: {final_image.size}")
+    
+    return final_image.convert("RGB")
+
+
 # Composition Workflow nach Ausgabe ControlnetInpaint-Pipeline
 def enhanced_composite_with_sam(original_image, inpaint_result, original_mask, 
                                 padding_info, bbox_coords, mode):