Update app.py

app.py

@@ -247,12 +247,13 @@ def scale_image_and_mask_together(image, mask, target_size=512, bbox_coords=None
     return padded_image, padded_mask, padding_info
 
 
+
 # Composition Workflow nach Ausgabe ControlnetInpaint-Pipeline
 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
+    COMPOSITING MIT SAM-MASKEN UND BBox-KOORDINATEN
+    Berücksichtigt die präzisen Kanten der SAM-Maske
     """
     print(f"🎨 Verbessertes Compositing für Modus: {mode}")
     
@@ -269,178 +270,118 @@ def enhanced_composite_with_sam(original_image, inpaint_result, original_mask,
     # 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")
+        print(f"✅ FALL 1: Bild 512×512 - kein Compositing nötig")
+        return inpaint_result
     
     # ==============================================
-    # FALL 2 & 3: Bild wurde skaliert - MASKE-BASIERTES COMPOSITING
+    # FALL 2 & 3: Bild wurde skaliert
     # ==============================================
-    print(f"🔄 FALL 2/3: Bild skaliert - MASKE-BASIERTES COMPOSITING")
+    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)
     )
     
-    # 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}")
+    # 2. AUF ORIGINALGRÖßE SKALIEREN
+    final_image = original_image.copy()
     
     if mode == "environment_change":
         # ==============================================
         # MODUS: UMWELT ÄNDERN (Objekt bleibt original)
+        # In dem Fall muß die BBox nicht berücksichtigt werden da Originalbild ausgeschnitten wird
+        # anhand der SAM-Maske
         # ==============================================
         print("🌳 Modus: Umwelt ändern mit SAM-Maske")
         
+        # Gesamtes bearbeitetes Bild hochskalieren
+        new_background = downscaled_result.resize(
+            (original_width, original_height), 
+            Image.Resampling.LANCZOS
+        )
+        
+        # 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(5))
-        
-        # Originalbild mit Alpha-Kanal
-        original_with_alpha = original_image.copy().convert("RGBA")
+        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"✅ Umwelt-Compositing abgeschlossen")
-        
     else:
         # ==============================================
-        # MODUS: FOCUS oder GESICHT ÄNDERN (MASKE-BASIERT)
+        # MODUS: FOCUS oder GESICHT ÄNDERN
+        # Hier muß die BBox berücksichtigt werden da generiertes Bild ausgeschnitten wird
+        # ohne die BBox wird entlang der SAM-Maske geschnitten -> ungenau!
         # ==============================================
         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)
+        print(f"👤 Modus: {mode_name} ändern mit SAM-Maske")
         
-        # 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()
+        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_width, original_height), 
+                Image.Resampling.LANCZOS
+            )
+            return final_image.convert("RGB")
+
+
+        #BBox-Koordinaten korrekt transformieren
+        #Die BBox-Koordinaten müssen vom Originalbild nach 512x512 transformiert werden
+        bbox_scaled = (
+            int(bbox_coords[0] * scale_factor),
+            int(bbox_coords[1] * scale_factor),
+            int(bbox_coords[2] * scale_factor),
+            int(bbox_coords[3] * scale_factor)         
+         )
+
+
+        #Mit den Padding-Offsets wird bei nicht quadratischen 512x512 Bildern
+        #das Padding hinzugefügt
+        bbox_in_512 = (
+            bbox_scaled[0] + x_offset,
+            bbox_scaled[1] + y_offset,
+            bbox_scaled[2] + x_offset,
+            bbox_scaled[3] + y_offset
+        )
+
+        if bbox_in_512[2] > bbox_in_512[0] and bbox_in_512[3] > bbox_in_512[1]:
+            # Bearbeiteten Bereich aus dem 512×512-Ergebnis ausschneiden
+            edited_region = inpaint_result.crop(bbox_in_512)
+
             
-            # 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)
+            # Auf ORIGINAL-BBox-Größe skalieren
+            original_bbox_size = (bbox_coords[2] - bbox_coords[0], 
+                                  bbox_coords[3] - bbox_coords[1])
+            edited_region_fullsize = edited_region.resize(
+                original_bbox_size, 
+                Image.Resampling.LANCZOS
+            )
             
-            mask_bbox_512 = (x_min, y_min, x_max, y_max)
+            # SAM-Maske für den Bereich zuschneiden und weichzeichnen
+            mask_cropped = original_mask.crop(bbox_coords)
+            soft_mask = mask_cropped.filter(ImageFilter.GaussianBlur(3))
             
-            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")
+            # Alpha-Compositing mit präziser SAM-Maske
+            edited_rgba = edited_region_fullsize.convert("RGBA")
+            mask_rgba = soft_mask.convert("L") # SAM-Maske als Alpha-Kanal
+            
+            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, (bbox_coords[0], bbox_coords[1]), temp_image)
     
     print(f"✅ Korrektes Compositing abgeschlossen. Finale Größe: {final_image.size}")
     
     return final_image.convert("RGB")
 
 
-
 def auto_detect_face_area(image):
     """Optimierten Vorschlag für Gesichtsbereich ohne externe Bibliotheken"""
     width, height = image.size