Update app.py

app.py

@@ -1,15 +1,16 @@
-# app.py - Streamlit für Hugging Face Spaces
+# app.py - Streamlit für Hugging Face Spaces (MIT REMBG-INTEGRATION)
 import os
 import tempfile
 import streamlit as st
 from PIL import Image
 import io
-import numpy as np # Immer noch nützlich, falls wir mal Arrays brauchen
+import numpy as np
+
+# NEUER IMPORT für die KI-gestützte Hintergrundentfernung
+from rembg import remove 
 
 # ----------------------------------------------------
 # 🚨 KRITISCHE FIXES FÜR DEN PERMISSION ERROR (beibehalten)
-# Zwingt Streamlit, seine temporären/Konfigurationsdateien
-# in den beschreibbaren /tmp-Bereich zu schreiben.
 # ----------------------------------------------------
 TEMP_STREAMLIT_HOME = os.path.join(tempfile.gettempdir(), "st_config_workaround")
 os.makedirs(TEMP_STREAMLIT_HOME, exist_ok=True)
@@ -28,11 +29,29 @@ enableCORS = false
 with open(CONFIG_PATH, "w") as f:
     f.write(CONFIG_CONTENT)
 
-# --- Bildverarbeitungsfunktionen ---
+# --- NEUE FUNKTION: Hintergrundentfernung mit KI ---
+
+def remove_background(image_pil):
+    """
+    Entfernt den Hintergrund eines Bildes mithilfe der rembg-Bibliothek.
+    Das Ergebnis ist ein PIL-Image mit Alpha-Kanal (RGBA).
+    """
+    # Konvertiere PIL Image zu Bytes für rembg (empfohlene Methode)
+    img_byte_arr = io.BytesIO()
+    image_pil.save(img_byte_arr, format='PNG')
+    input_bytes = img_byte_arr.getvalue()
+    
+    # KI-Operation: Hintergrund entfernen
+    # Da wir auf CPU laufen, kann dies einige Sekunden dauern!
+    output_bytes = remove(input_bytes, alpha_matting=True)
+    
+    # Konvertiere die Ergebnis-Bytes zurück zu einem PIL Image
+    return Image.open(io.BytesIO(output_bytes))
+
+# --- Bildverarbeitungsfunktionen (Unverändert) ---
 
 def stack_horizontal(img1, img2):
-    """Stapelt zwei Bilder horizontal nebeneinander."""
-    # Wandelt in RGB um, um die Transparenz in diesem Modus zu ignorieren
+    # ... (Code unverändert) ...
     img1 = img1.convert("RGB") 
     img2 = img2.convert("RGB")
     
@@ -51,8 +70,7 @@ def stack_horizontal(img1, img2):
     return stacked_img
 
 def blend_images_cpu(img1, img2, alpha):
-    """Blendet zwei Bilder mit Alpha-Faktor."""
-    # Konvertiert in RGBA, um Transparenz beim Blenden zu unterstützen
+    # ... (Code unverändert) ...
     img1 = img1.convert("RGBA") 
     img2 = img2.convert("RGBA")
     
@@ -60,43 +78,29 @@ def blend_images_cpu(img1, img2, alpha):
         img2 = img2.resize(img1.size, Image.Resampling.LANCZOS)
         
     blended = Image.blend(img1, img2, alpha)
-    return blended.convert("RGB") # Rückgabe als RGB für Konsistenz im UI, wenn nicht transparent sein muss
+    return blended.convert("RGB") 
 
 def overlay_image(background_img, overlay_img, x_pos, y_pos, scale_factor):
-    """
-    Überlagert ein freigestelltes Bild (overlay_img, muss RGBA sein) 
-    auf ein Hintergrundbild (background_img).
-    Position und Skalierung sind einstellbar.
-    """
-    # Hintergrundbild immer als RGBA behandeln, um Alpha-Kanal zu ermöglichen
+    # ... (Code unverändert) ...
     background = background_img.convert("RGBA")
-
-    # Overlay-Bild muss RGBA haben, um Transparenz zu unterstützen
     overlay = overlay_img.convert("RGBA")
 
-    # Skalierung anwenden
     new_width = int(overlay.width * scale_factor)
     new_height = int(overlay.height * scale_factor)
     overlay = overlay.resize((new_width, new_height), Image.Resampling.LANCZOS)
 
-    # Erstelle ein leeres Bild mit der Größe des Hintergrundbildes im RGBA-Modus
-    # und paste das Hintergrundbild hinein
     result = Image.new("RGBA", background.size)
-    result.paste(background, (0, 0)) # Füge das Hintergrundbild ein
+    result.paste(background, (0, 0))
+    result.paste(overlay, (x_pos, y_pos), overlay)
 
-    # Überlagere das zweite Bild (Katze) an der gewünschten Position
-    # Die paste-Methode von Pillow verwendet den Alpha-Kanal des "mask"-Arguments,
-    # wenn das überlagernde Bild einen Alpha-Kanal hat und als Maske übergeben wird.
-    result.paste(overlay, (x_pos, y_pos), overlay) # 'overlay' als Maske verwenden
-
-    return result.convert("RGB") # Rückgabe als RGB für die Anzeige
+    return result.convert("RGB") 
 
 
 # --- Streamlit UI ---
 st.set_page_config(page_title="Image Transformer", layout="wide")
 
-st.title("🖼️ CPU Image Transformer (Blend, Stack, Overlay)")
-st.markdown("**Blend** (überblenden), **Stack** (aneinanderreihen) oder **Overlay** (Katze auf Toilette 😎) - Reine CPU-Operation")
+st.title("🖼️ CPU Image Transformer (Blend, Stack, KI-Overlay)")
+st.markdown("**Blend** (überblenden), **Stack** (aneinanderreihen) oder **KI-Overlay** (Katze auf Klo!) - Reine CPU-Operation.")
 
 col1, col2 = st.columns(2)
 
@@ -112,10 +116,22 @@ with col1:
     
     # Overlay-Parameter (nur bei Overlay relevant)
     with st.expander("Overlay-Optionen", expanded=(method == "Overlay (Position & Scale)")):
+        
+        # NEUES UI-ELEMENT: KI-Freistellung
+        auto_remove_bg = st.checkbox(
+            "Automatisch freistellen (KI)", 
+            value=False, 
+            disabled=(method != "Overlay (Position & Scale)"),
+            help="Nutzt ein KI-Modell, um den Hintergrund von Bild 2 zu entfernen. **Achtung: Dies ist eine CPU-intensive Operation und kann die Verarbeitungszeit erhöhen.**"
+        )
+        st.divider() # Trennlinie
+        
         x_pos = st.slider("X-Position des Overlays", 0, 1000, 0, 10, disabled=(method != "Overlay (Position & Scale)"))
         y_pos = st.slider("Y-Position des Overlays", 0, 1000, 0, 10, disabled=(method != "Overlay (Position & Scale)"))
         scale_factor = st.slider("Skalierung des Overlays", 0.1, 3.0, 1.0, 0.1, disabled=(method != "Overlay (Position & Scale)"))
-        st.info("Für 'Overlay' sollte Bild 2 ein freigestelltes PNG mit Transparenz sein!")
+        
+        if not auto_remove_bg:
+            st.info("Wenn **nicht** freigestellt wird, muss Bild 2 bereits ein **transparentes PNG** sein!")
     
     process_btn = st.button("🚀 Verarbeiten", type="primary")
 
@@ -137,15 +153,22 @@ if process_btn:
                 elif method == "Stack Horizontal":
                     result = stack_horizontal(img1, img2)
                 elif method == "Overlay (Position & Scale)":
-                    # Hier ist es wichtig, dass img2 (Katze) einen Alpha-Kanal hat
-                    result = overlay_image(img1, img2, x_pos, y_pos, scale_factor)
+                    
+                    # KI-Freistellungslogik HIER
+                    overlay_img_final = img2
+                    if auto_remove_bg:
+                        st.text("KI: Hintergrund von Bild 2 wird entfernt...")
+                        overlay_img_final = remove_background(img2)
+                        st.text("KI: Freistellung abgeschlossen.")
+
+                    result = overlay_image(img1, overlay_img_final, x_pos, y_pos, scale_factor)
                 
                 if result:
                     result_placeholder.image(result, use_container_width=True)
                     
                     # Download-Button
                     buf = io.BytesIO()
-                    result.save(buf, format="PNG") # PNG für Transparenz bei Overlay
+                    result.save(buf, format="PNG") # PNG ist wichtig, da es den Alpha-Kanal für den Download beibehält
                     st.download_button(
                         label="💾 Download Resultat",
                         data=buf.getvalue(),
@@ -153,6 +176,9 @@ if process_btn:
                         mime="image/png"
                     )
             except Exception as e:
-                st.error(f"Fehler: {e}")
+                st.error(f"Fehler bei der Verarbeitung: {e}")
+                # Füge hier weitere Debug-Informationen hinzu, wenn das Modell nicht lädt
+                if "No such file or directory" in str(e):
+                    st.error("WICHTIG: Die KI-Modell-Dateien wurden nicht gefunden. Stelle sicher, dass `rembg` alle Abhängigkeiten korrekt geladen hat.")
     else:
         st.warning("⚠️ Bitte beide Bilder hochladen!")