Update app.py

app.py

@@ -5,8 +5,7 @@ from PIL import Image, ImageDraw
 import time
 import os
 import tempfile
-import cv2
-import numpy as np
+import random
 
 # === OPTIMIERTE EINSTELLUNGEN ===
 device = "cuda" if torch.cuda.is_available() else "cpu"
@@ -15,45 +14,38 @@ IMG_SIZE = 512
 
 print(f"Running on: {device}")
 
-# === GESICHTSERKENNUNG ===
-CASCADE_PATH = cv2.data.haarcascades + "haarcascade_frontalface_default.xml"
-
-def detect_face_bbox(pil_image):
-    """Gibt (x1, y1, x2, y2) für das erkannte Gesicht zurück oder None."""
-    try:
-        cv_image = np.array(pil_image.convert("RGB"))[:, :, ::-1]  # PIL → OpenCV (BGR)
-        gray = cv2.cvtColor(cv_image, cv2.COLOR_BGR2GRAY)
-        face_cascade = cv2.CascadeClassifier(CASCADE_PATH)
-        faces = face_cascade.detectMultiScale(gray, 1.2, 6)
-
-        if len(faces) == 0:
-            print("⚠️ Kein Gesicht erkannt – keine Maske angewendet.")
-            return None
-
-        # Nimm das größte erkannte Gesicht
-        (x, y, w, h) = sorted(faces, key=lambda f: f[2]*f[3], reverse=True)[0]
-
-        # Erweitere den Bereich leicht, um Haare / Stirn einzuschließen
-        pad = int(h * 0.25)
-        bbox = (max(0, x - pad), max(0, y - pad), 
-                min(cv_image.shape[1], x + w + pad), 
-                min(cv_image.shape[0], y + h + pad))
-        
-        print(f"✅ Gesicht erkannt: {bbox}")
-        return bbox
-        
-    except Exception as e:
-        print(f"❌ Fehler bei Gesichtserkennung: {e}")
-        return None
-
-def create_face_mask(image, bbox):
-    """Erzeugt eine runde Gesichtsmaske aus Koordinaten."""
-    mask = Image.new("L", image.size, 0)
-    if bbox is not None:
+# === GESICHTSMASKEN-FUNKTIONEN ===
+def create_face_mask(image, bbox_coords):
+    """Erzeugt eine Gesichtsmaske - WEIßE Bereiche werden VERÄNDERT, SCHWARZE BLEIBEN"""
+    mask = Image.new("L", image.size, 0)  # Start mit komplett schwarzer Maske (alles geschützt)
+    
+    if bbox_coords and all(coord is not None for coord in bbox_coords):
+        x1, y1, x2, y2 = bbox_coords
         draw = ImageDraw.Draw(mask)
-        draw.ellipse(bbox, fill=255)
+        
+        if face_preserve:
+            # GESICHTSERHALTUNG: Maske um das Gesicht herum zeichnen
+            # Das Gesicht bleibt schwarz (geschützt), der Rest wird weiß (verändert)
+            draw.rectangle([0, 0, image.size[0], image.size[1]], fill=255)  # Alles weiß = alles verändern
+            draw.ellipse([x1, y1, x2, y2], fill=0)  # Gesicht schwarz = geschützt
+            print("✅ Gesicht wird GESCHÜTZT - Umgebung wird verändert")
+        else:
+            # NUR GESICHT VERÄNDERN: Nur das Gesicht wird weiß (verändert), Rest schwarz (geschützt)
+            draw.ellipse([x1, y1, x2, y2], fill=255)  # Gesicht weiß = verändern
+            print("✅ Nur Gesicht wird verändert - Umgebung bleibt erhalten")
+    
     return mask
 
+def auto_detect_face_area(image):
+    """Vorschlag für Gesichtsbereich"""
+    width, height = image.size
+    face_size = min(width, height) * 0.4
+    x1 = (width - face_size) / 2
+    y1 = (height - face_size) / 3
+    x2 = x1 + face_size
+    y2 = y1 + face_size
+    return [int(x1), int(y1), int(x2), int(y2)]
+
 # === PIPELINES ===
 pipe_txt2img = None
 pipe_img2img = None
@@ -70,10 +62,8 @@ def load_txt2img():
             requires_safety_checker=False
         ).to(device)
         
-        # DPMSolver für Text-to-Image
         from diffusers import DPMSolverMultistepScheduler
         pipe_txt2img.scheduler = DPMSolverMultistepScheduler.from_config(pipe_txt2img.scheduler.config)
-        
         pipe_txt2img.enable_attention_slicing()
     return pipe_txt2img
 
@@ -89,21 +79,16 @@ def load_img2img():
             requires_safety_checker=False
         ).to(device)
         
-        # --- OPTIMIERTER SAMPLER ---
         from diffusers import DPMSolverMultistepScheduler
         pipe_img2img.scheduler = DPMSolverMultistepScheduler.from_config(
             pipe_img2img.scheduler.config,
             algorithm_type="sde-dpmsolver++",
             use_karras_sigmas=True,
-            # wichtig: linear_multistep statt linspace ergibt natürlichere Übergänge
             timestep_spacing="trailing"
         )
         
-        # Effiziente Speicherverwaltung
         pipe_img2img.enable_attention_slicing()
         pipe_img2img.enable_vae_tiling()
-
-        # Optional: für stabilere Farberhaltung
         pipe_img2img.vae_slicing = True
 
     return pipe_img2img
@@ -115,13 +100,14 @@ def text_to_image(prompt, steps, guidance_scale):
             return None
             
         print(f"Starting generation for: {prompt}")
-        print(f"Parameters - Steps: {steps}, Guidance Scale: {guidance_scale}")
         start_time = time.time()
         
         pipe = load_txt2img()
         
-        # Seed für Reproduzierbarkeit (-1 = zufällig)
-        generator = torch.Generator(device=device).manual_seed(-1)
+        # ZUFÄLLIGER SEED für Variation
+        seed = random.randint(0, 2**32 - 1)
+        generator = torch.Generator(device=device).manual_seed(seed)
+        print(f"🎲 Using seed: {seed}")
         
         image = pipe(
             prompt=prompt,
@@ -135,7 +121,7 @@ def text_to_image(prompt, steps, guidance_scale):
         end_time = time.time()
         print(f"✅ Bild generiert in {end_time - start_time:.2f} Sekunden")
         
-        return image  # Direkte Rückgabe aus RAM
+        return image
         
     except Exception as e:
         print(f"❌ Fehler: {e}")
@@ -143,46 +129,62 @@ def text_to_image(prompt, steps, guidance_scale):
         traceback.print_exc()
         return None
 
-def img_to_image(image, prompt, neg_prompt, strength, steps, guidance_scale, face_preserve):
+def img_to_image(image, prompt, neg_prompt, strength, steps, guidance_scale, face_preserve, bbox_x1, bbox_y1, bbox_x2, bbox_y2):
     try:
         if image is None:
             return None
 
         print(f"🧩 Img2Img Start → Strength: {strength}, Steps: {steps}, Guidance: {guidance_scale}")
         print(f"Prompt: {prompt}")
-        print(f"Negative: {neg_prompt}")
         print(f"Gesicht beibehalten: {face_preserve}")
         start_time = time.time()
 
         pipe = load_img2img()
-
-        # --- PREPROCESSING ---
         img_resized = image.convert("RGB").resize((IMG_SIZE, IMG_SIZE))
 
         # --- PARAMETER-TUNING ---
-        # Anpassung, um sde-dpmsolver++ realistischer wirken zu lassen:
-        adj_strength = min(0.85, strength * 1.3)   # mehr effektives Rauschen
-        adj_guidance = min(guidance_scale, 7.0)    # CLIP-Zwang begrenzen
-
-        # --- REPRODUZIERBARER SEED (optional -1 = zufällig) ---
-        generator = torch.Generator(device=device).manual_seed(-1)
+        adj_strength = min(0.85, strength * 1.3)
+        adj_guidance = min(guidance_scale, 7.0)
+        
+        # ZUFÄLLIGER SEED für Variation
+        seed = random.randint(0, 2**32 - 1)
+        generator = torch.Generator(device=device).manual_seed(seed)
+        print(f"🎲 Using seed: {seed}")
 
-        # --- AUTOMATISCHE GESICHTSMASKE ---
+        # --- GESICHTSMASKE ---
         mask = None
-        if face_preserve:
-            bbox = detect_face_bbox(img_resized)
-            mask = create_face_mask(img_resized, bbox)
+        bbox_coords = None
+        
+        if bbox_x1 is not None and bbox_y1 is not None and bbox_x2 is not None and bbox_y2 is not None:
+            # Skaliere Koordinaten auf die neue Bildgröße
+            orig_width, orig_height = image.size
+            scale_x = IMG_SIZE / orig_width
+            scale_y = IMG_SIZE / orig_height
+            
+            scaled_coords = [
+                int(bbox_x1 * scale_x),
+                int(bbox_y1 * scale_y),
+                int(bbox_x2 * scale_x),
+                int(bbox_y2 * scale_y)
+            ]
+            bbox_coords = scaled_coords
+            print(f"📐 Skalierte Koordinaten: {scaled_coords}")
+
+        # Maskenlogik basierend auf face_preserve
+        if bbox_coords:
+            mask = create_face_mask(img_resized, bbox_coords)
             if mask:
-                print("✅ Gesichtsmaske erstellt")
-            else:
-                print("⚠️ Keine Gesichtsmaske verfügbar")
+                print("✅ Maske erfolgreich erstellt")
+        else:
+            print("⚠️ Keine gültigen Koordinaten - keine Maske angewendet")
+            mask = None
 
         # --- PIPELINE-AUFRUF ---
         result = pipe(
             prompt=prompt,
             negative_prompt=neg_prompt,
             image=img_resized,
-            mask_image=mask,  # Wird None sein wenn face_preserve=False oder kein Gesicht erkannt
+            mask_image=mask,  # None = gesamtes Bild verändern
             strength=adj_strength,
             num_inference_steps=int(steps),
             guidance_scale=adj_guidance,
@@ -192,27 +194,20 @@ def img_to_image(image, prompt, neg_prompt, strength, steps, guidance_scale, fac
         end_time = time.time()
         print(f"✅ Bild transformiert in {end_time - start_time:.2f} Sekunden")
         
-        generated_image = result.images[0]  # Bild aus RAM
-        
-        # === TEMP-SPEICHERUNG ALS FALLBACK ===
+        generated_image = result.images[0]
+
+        # Temp-Speicherung
         try:
-            # Erstelle Temp-Verzeichnis falls nicht vorhanden
             temp_dir = "/tmp/gradio_fallback"
             os.makedirs(temp_dir, exist_ok=True)
-            
-            # Speichere Bild temporär
             temp_path = os.path.join(temp_dir, f"generated_{int(time.time())}.png")
             generated_image.save(temp_path, "PNG")
-            print(f"💾 Bild temporär gespeichert: {temp_path}")
-            
-            # Lade Bild wieder für konsistente Rückgabe
             saved_image = Image.open(temp_path)
-            
         except Exception as temp_error:
             print(f"⚠️ Temp-Speicherung fehlgeschlagen: {temp_error}")
-            saved_image = generated_image  # Fallback auf RAM-Bild
+            saved_image = generated_image
         
-        return saved_image  # Rückgabe des gespeicherten oder RAM-Bildes
+        return saved_image
         
     except Exception as e:
         print(f"❌ Fehler: {e}")
@@ -220,6 +215,14 @@ def img_to_image(image, prompt, neg_prompt, strength, steps, guidance_scale, fac
         traceback.print_exc()
         return None
 
+def update_bbox_from_image(image):
+    """Aktualisiert die Bounding-Box-Koordinaten wenn ein Bild hochgeladen wird"""
+    if image is None:
+        return None, None, None, None
+    
+    bbox = auto_detect_face_area(image)
+    return bbox[0], bbox[1], bbox[2], bbox[3]
+
 # === UI ===
 with gr.Blocks() as app:
     gr.Markdown("# 🎨 AI Bild Generator")
@@ -246,13 +249,6 @@ with gr.Blocks() as app:
                     label="Guidance Scale (Prompt-Treue vs. Verzerrung)"
                 )
         
-        with gr.Row():
-            gr.Markdown(
-                "**Parameter-Erklärung:**  "
-                "• **Steps:** Mehr = bessere Qualität, aber langsamer  "
-                "• **Guidance:** Niedrig = weniger Verzerrung, Hoch = mehr KI-Fantasie  "
-            )
-        
         generate_btn = gr.Button("🎨 Bild generieren", variant="primary")
         txt_output = gr.Image(
             label="Generiertes Bild", 
@@ -279,15 +275,15 @@ with gr.Blocks() as app:
         with gr.Row():
             with gr.Column():
                 img_prompt = gr.Textbox(
-                    placeholder="background only: winter forest, keep girl and snowman unchanged",
+                    placeholder="change background to forest, keep face unchanged",
                     lines=2,
                     label="Transformations-Prompt (Englisch)"
                 )
             with gr.Column():
                 img_neg_prompt = gr.Textbox(
-                    placeholder="blurry, deformed, ugly, bad anatomy, distorted faces",
+                    placeholder="blurry, deformed, ugly, bad anatomy",
                     lines=2,
-                    label="Negativ-Prompt (was vermieden werden soll)"
+                    label="Negativ-Prompt"
                 )
         
         with gr.Row():
@@ -299,30 +295,37 @@ with gr.Blocks() as app:
             with gr.Column():
                 img_steps = gr.Slider(
                     minimum=10, maximum=100, value=35, step=1,
-                    label="Steps (Qualität vs. Geschwindigkeit)"
+                    label="Steps"
                 )
             with gr.Column():
                 img_guidance = gr.Slider(
                     minimum=1.0, maximum=20.0, value=7.5, step=0.5,
-                    label="Guidance Scale (Prompt-Treue vs. Verzerrung)"
+                    label="Guidance Scale"
                 )
         
-        # NEUE CHECKBOX FÜR GESICHTSERHALTUNG
+        # GESICHTSOPTIONEN
         with gr.Row():
             face_preserve = gr.Checkbox(
-                label="👤 Gesicht automatisch erkennen und beibehalten", 
+                label="👤 Gesicht beibehalten (Umgebung verändern)", 
                 value=True,
-                info="Erkennt Gesichter und schützt sie vor Veränderung"
+                info="Gesicht bleibt erhalten, Hintergrund wird verändert"
             )
         
+        with gr.Row():
+            gr.Markdown("**Gesichtsbereich definieren (x1, y1, x2, y2):**")
+        
+        with gr.Row():
+            bbox_x1 = gr.Number(label="x1 (links)", value=100, precision=0)
+            bbox_y1 = gr.Number(label="y1 (oben)", value=100, precision=0)
+            bbox_x2 = gr.Number(label="x2 (rechts)", value=300, precision=0)
+            bbox_y2 = gr.Number(label="y2 (unten)", value=300, precision=0)
+        
         with gr.Row():
             gr.Markdown(
-                "**Parameter-Erklärung:**  "
-                "• **Strength:** Niedrig = behält Original, Hoch = starke Veränderung  "
-                "• **Steps:** Mehr = bessere Qualität, aber langsamer  "
-                "• **Guidance:** Niedrig = weniger Verzerrung, Hoch = mehr KI-Fantasie  "
-                "• **Negativ-Prompt:** Beschreibt was NICHT im Bild sein soll  "
-                "• **Gesicht beibehalten:** Automatische Gesichtserkennung schützt Porträts  "
+                "**Anleitung:**  "
+                "• **Gesicht beibehalten** = Gesicht bleibt, Hintergrund ändert sich  "
+                "• **Nicht aktiviert** = Nur Gesicht ändert sich, Hintergrund bleibt  "
+                "• **Koordinaten anpassen** um den genauen Bereich zu definieren  "
             )
         
         transform_btn = gr.Button("🔄 Bild transformieren", variant="primary")
@@ -333,9 +336,20 @@ with gr.Blocks() as app:
                 show_download_button=True
             )
         
+        # Event-Handler für Bild-Upload
+        img_input.change(
+            fn=update_bbox_from_image,
+            inputs=[img_input],
+            outputs=[bbox_x1, bbox_y1, bbox_x2, bbox_y2]
+        )
+        
         transform_btn.click(
             fn=img_to_image,
-            inputs=[img_input, img_prompt, img_neg_prompt, strength_slider, img_steps, img_guidance, face_preserve],
+            inputs=[
+                img_input, img_prompt, img_neg_prompt, 
+                strength_slider, img_steps, img_guidance, 
+                face_preserve, bbox_x1, bbox_y1, bbox_x2, bbox_y2
+            ],
             outputs=img_output,
             concurrency_limit=1
         )