Update app.py

app.py

@@ -197,41 +197,37 @@ def text_to_image(prompt, steps, guidance_scale, progress=gr.Progress()):
         traceback.print_exc()
         return None
 
-def img_to_image(image, prompt, neg_prompt, strength, steps, guidance_scale, face_preserve, bbox_x1, bbox_y1, bbox_x2, bbox_y2, progress=gr.Progress()):
+def img_to_image(image, prompt, neg_prompt, strength, steps, guidance_scale,
+                 face_preserve, bbox_x1, bbox_y1, bbox_x2, bbox_y2,
+                 progress=gr.Progress()):
     try:
         if image is None:
             return None
 
+        import time, random
+        start_time = time.time()
+
         print(f"Img2Img Start → Strength: {strength}, Steps: {steps}, Guidance: {guidance_scale}")
         print(f"Prompt: {prompt}")
         print(f"Negativ-Prompt: {neg_prompt}")
         print(f"Gesicht beibehalten: {face_preserve}")
-        start_time = time.time()
 
-        # Statusmeldung anzeigen zur Zeitüberbrückung
-        progress(0, desc="Generierung läuft - CPU benötigt bis zu 20 Minuten!")
+        progress(0, desc="Starte Generierung mit ControlNet...")
 
-        # --- Progress-Balken zur Überbrückung für 0te Step von CONTROLNET---
-        progress(0.05, desc="ControlNet: Pose-Erkennung...")
-        
-        # Parameter-Tuning für ControlNet
-        adj_strength = min(0.85, strength * 1.3)
-        actual_steps_from_strength = int(steps * adj_strength)
-        controlnet_steps = min(25, actual_steps_from_strength)
-        
-        print(f"🎯 ControlNet Step-Kalkulation: UI={steps}, Adj-Strength={adj_strength:.3f}, Echte Steps={actual_steps_from_strength}, ControlNet-Steps={controlnet_steps}")
+        # -------------------------------
+        # PARAMETER-TUNING
+        # -------------------------------
+        adj_strength = min(0.85, strength * 1.25)
+        controlnet_strength = adj_strength * (0.8 if face_preserve else 0.5)
+        controlnet_steps = min(25, int(steps * 0.8))
 
-        # --- KONTROLLNET-STRENGTH ANPASSEN ABHÄNGIG VOM MODUS ---
-        if face_preserve:
-            # UMGEBUNG BEIBEHALTEN, PERSON ÄNDERN → HOHE STRENGTH FÜR CANNY
-            controlnet_strength = adj_strength * 0.8  # 80% für Canny
-            print(f"🎯 ControlNet Canny Modus: Strength = {controlnet_strength:.3f} (80% von {adj_strength:.3f})")
-        else:
-            # PERSON BEIBEHALTEN, UMGEBUNG ÄNDERN → NORMALE STRENGTH FÜR OPENPOSE
-            controlnet_strength = adj_strength * 0.5  # 50% für OpenPose
-            print(f"🎯 ControlNet OpenPose Modus: Strength = {controlnet_strength:.3f} (50% von {adj_strength:.3f})")
+        print(f"🎯 Steps={steps}, ControlNet-Steps={controlnet_steps}, Strength={controlnet_strength:.3f}")
+
+        # -------------------------------
+        # CONTROLNET GENERIERUNG
+        # -------------------------------
+        progress(0.05, desc="Erstelle ControlNet Maps...")
 
-        # ControlNet Modul aufrufen - MIT ZWEI RÜCKGABEWERTEN
         controlnet_output, inpaint_input = controlnet_processor.generate_with_controlnet(
             image=image,
             prompt=prompt,
@@ -239,74 +235,57 @@ def img_to_image(image, prompt, neg_prompt, strength, steps, guidance_scale, fac
             steps=controlnet_steps,
             guidance_scale=guidance_scale,
             controlnet_strength=controlnet_strength,
-            progress=progress,
-            keep_environment=face_preserve
+            progress=progress
         )
-        
+
         print(f"✅ ControlNet Output erhalten: {type(controlnet_output)}")
-        print(f"✅ Inpaint Input erhalten: {type(inpaint_input)}")
-        
-        #Progress-Balken zur Überbrückung für 0ten Step von Inpaint
-        progress(0.3, desc="ControlNet fertig, starte Inpaint...")
 
-        # --- INPAINT PIPELINE ---
-        pipe = load_img2img()
-        
-        # inpaint_input verwenden (IMMER Originalbild)
+        # -------------------------------
+        # INPAINT (STABLE DIFFUSION IMG2IMG)
+        # -------------------------------
+        progress(0.3, desc="ControlNet abgeschlossen – starte Inpaint...")
+
+        pipe = load_img2img()  # ← deine bestehende Funktion
         img_resized = inpaint_input.convert("RGB").resize((IMG_SIZE, IMG_SIZE))
 
-        # --- PARAMETER-TUNING ---
         adj_guidance = min(guidance_scale, 12.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}")
 
-        # --- GESICHTSMASKE ---
+        # -------------------------------
+        # GESICHTS-MASKE (falls Koordinaten)
+        # -------------------------------
         mask = None
-        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 = [
+        if bbox_x1 and bbox_y1 and bbox_x2 and bbox_y2:
+            orig_w, orig_h = image.size
+            scale_x, scale_y = IMG_SIZE / orig_w, IMG_SIZE / orig_h
+            bbox_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:
+            print(f"Skalierte Koordinaten: {bbox_coords}")
             mask = create_face_mask(img_resized, bbox_coords, face_preserve)
             if mask:
-                print("Maske erfolgreich erstellt")
+                print("✅ Maske erfolgreich erstellt")
         else:
-            print("Keine gültigen Koordinaten - keine Maske angewendet")
-            mask = None
-
-        # Detaillierte Debug-Informationen vor dem Pipeline-Aufruf
-        print(f"⚙️  PIPELINE-KONFIGURATION:")
-        print(f"   - Angefordert: {int(steps)} Steps")
-        print(f"   - Strength: {adj_strength:.3f}")
-        print(f"   - Scheduler: {pipe.scheduler.__class__.__name__}")
+            print("⚠️ Keine gültigen Koordinaten – keine Maske")
 
-        print(f"🎯 KORREKTE INTERNE STEP-AUSGABE: {int(steps)} Steps × Strength {adj_strength:.3f} = {actual_steps_from_strength} tatsächliche Schritte")
+        # -------------------------------
+        # PIPELINE-AUFRUF
+        # -------------------------------
+        from diffusers import EulerAncestralDiscreteScheduler
+        if not isinstance(pipe.scheduler, EulerAncestralDiscreteScheduler):
+            pipe.scheduler = EulerAncestralDiscreteScheduler.from_config(pipe.scheduler.config)
 
-        # NEUE Callback-Implementierung
         callback = ImageToImageProgressCallback(progress, int(steps), adj_strength)
 
-        # --- PIPELINE-AUFRUF MIT KORREKTEM INPUT ---
         result = pipe(
             prompt=prompt,
             negative_prompt=neg_prompt,
-            image=img_resized,  # inpaint_input (Originalbild)
+            image=img_resized,
             mask_image=mask,
             strength=adj_strength,
             num_inference_steps=int(steps),
@@ -316,28 +295,14 @@ def img_to_image(image, prompt, neg_prompt, strength, steps, guidance_scale, fac
             callback_on_step_end_tensor_inputs=[],
         )
 
-        # ZUSÄTZLICHE AUSGABE: Tatsächliche Steps
-        try:
-            scheduler = pipe.scheduler
-            print(f"🔧 SCHEDULER-INFO: {scheduler.__class__.__name__}")
-            print(f"📊 TATSÄCHLICHE STEP-KONFIGURATION: {int(steps)} Schritte mit Strength {adj_strength:.3f}")
-    
-            if hasattr(scheduler, 'timesteps'):
-                actual_steps = len(scheduler.timesteps)
-                print(f"🎯 BESTÄTIGTE INTERNE STEP-AUSGABE: Scheduler verwendete {actual_steps} tatsächliche Denoising-Schritte")
-        
-        except Exception as e:
-            print(f"⚠️  Konnte Scheduler-Info nicht auslesen: {e}")
-
         end_time = time.time()
-        print(f"Bild transformiert in {end_time - start_time:.2f} Sekunden")
-        
-        generated_image = result.images[0]
+        print(f"🕒 Dauer: {end_time - start_time:.2f} Sekunden")
 
+        generated_image = result.images[0]
         return generated_image
-        
+
     except Exception as e:
-        print(f"Fehler: {e}")
+        print(f"❌ Fehler in img_to_image: {e}")
         import traceback
         traceback.print_exc()
         return None