Update app.py

app.py

@@ -25,6 +25,7 @@ MODEL_CONFIGS = {
         "name": "🏠 Stable Diffusion 1.5 (Universal)",
         "description": "Universal model, good all-rounder, reliable results",
         "requires_vae": False,
+        "vae_model": "stabilityai/sd-vae-ft-mse",
         "recommended_steps": 35,
         "recommended_cfg": 7.5,
         "supports_fp16": True
@@ -163,6 +164,136 @@ def create_face_mask(image, bbox_coords, mode):
     
     return mask
 
+# === KORREKTE GEMEINSAME PROPORTIONALE SKALIERUNG MIT PADDING ===
+def scale_image_and_mask_together(image, mask, target_size=512):
+    """
+    SKALIERT BILD UND MASKE GEMEINSAM MIT GLEICHEN PROPORTIONEN (MIT PADDING)
+    Behält das Seitenverhältnis bei und fügt ggf. Padding hinzu
+    
+    Parameter:
+    - image: PIL Image (RGB)
+    - mask: PIL Image (L-Modus, Maske)
+    - target_size: Zielgröße (Standard 512)
+    
+    Returns:
+    - padded_image: skaliertes Bild mit Padding (RGB)
+    - padded_mask: skalierte Maske mit Padding (L)
+    - padding_info: Dictionary mit Skalierungsinfo für späteres Compositing
+    """
+    if image is None or mask is None:
+        raise ValueError("Bild oder Maske ist None")
+    
+    if image.size != mask.size:
+        raise ValueError(f"Bild und Maske haben unterschiedliche Größen: {image.size} vs {mask.size}") #Stoppt Programm sofort mit Fehlermeldung!
+
+    #Variablen für Bildmaße
+    original_width, original_height = image.size
+    
+    # Bestimme Skalierungsfaktor (längere Seite auf target_size)
+    scale = target_size / max(original_width, original_height)
+    
+    new_width = int(original_width * scale)
+    new_height = int(original_height * scale)
+    
+    print(f"📐 Gemeinsame Skalierung: {original_width}x{original_height} → {new_width}x{new_height} (Skalierung: {scale:.4f})")
+    
+    # Skaliere Bild und Maske
+    scaled_image = image.resize((new_width, new_height), Image.Resampling.LANCZOS)
+    scaled_mask = mask.resize((new_width, new_height), Image.Resampling.NEAREST)
+    
+    # Auf Zielgröße padden (zentriert)
+    #Image.new("RGB", (target_size, target_size), (0, 0, 0)) erstellt ein neues, leeres, schwarzes Bild in der Ziel-Verarbeitungsgröße deines Modells (512×512 für SD 1.5 oder 1024×1024 für SDXL)
+    padded_image = Image.new("RGB", (target_size, target_size), (0, 0, 0))
+    padded_mask = Image.new("L", (target_size, target_size), 0)
+    
+    # Zentrierte Position berechnen
+    x_offset = (target_size - new_width) // 2
+    y_offset = (target_size - new_height) // 2
+    
+    padded_image.paste(scaled_image, (x_offset, y_offset))
+    padded_mask.paste(scaled_mask, (x_offset, y_offset))
+    
+    # WICHTIG: Speichere alle Informationen für späteres Compositing
+    padding_info = {
+        'x_offset': x_offset,
+        'y_offset': y_offset,
+        'scaled_width': new_width,
+        'scaled_height': new_height,
+        'original_width': original_width,
+        'original_height': original_height,
+        'scale_factor': scale,
+        'target_size': target_size
+    }
+    
+    print(f"📦 Padding hinzugefügt: Offsets ({x_offset}, {y_offset})")
+    
+    return padded_image, padded_mask, padding_info
+
+# === KORREKTE COMPOSITING-FUNKTION ===
+def composite_edited_region(original_image, inpaint_result, original_mask, padding_info):
+    """
+    KORREKTER COMPOSITING-WORKFLOW:
+    - Schneidet den bearbeiteten Bereich aus dem Inpaint-Ergebnis
+    - Fügt ihn nahtlos in das Originalbild ein
+    
+    Parameter:
+    - original_image: Originalbild in Originalgröße
+    - inpaint_result: 512x512 Inpaint-Ergebnis
+    - original_mask: Originalmaske (vor Skalierung)
+    - padding_info: Skalierungsinformationen von scale_image_and_mask_together()
+    
+    Returns:
+    - composited_image: Finales Bild mit bearbeiteter Region
+    """
+    print(f"🎨 Starte korrektes Compositing...")
+    
+    # 1. Extrahiere den bearbeiteten Bereich aus dem Inpaint-Ergebnis (ohne Padding)
+    x_offset = padding_info['x_offset']
+    y_offset = padding_info['y_offset']
+    scaled_width = padding_info['scaled_width']
+    scaled_height = padding_info['scaled_height']
+    
+    # Bereich im 512x512 Inpaint-Ergebnis, der dem originalen Bild entspricht
+    unpainted_region = inpaint_result.crop(
+        (x_offset, y_offset, x_offset + scaled_width, y_offset + scaled_height)
+    )
+    
+    print(f"   Bearbeiteter Bereich extrahiert: {unpainted_region.size}")
+    
+    # 2. Skaliere den bearbeiteten Bereich zurück auf Originalgröße
+    original_size = (padding_info['original_width'], padding_info['original_height'])
+    edited_region_fullsize = unpainted_region.resize(original_size, Image.Resampling.LANCZOS)
+    
+    print(f"   Auf Originalgröße skaliert: {edited_region_fullsize.size}")
+    
+    # 3. Erstelle eine weiche Maske für nahtloses Einfügen
+    # Erweitere die Originalmaske leicht für weiche Übergänge
+    soft_mask = original_mask.copy()
+    
+    # Für weiche Kanten: Erweitere die Maske um 5 Pixel
+    from PIL import ImageFilter
+    soft_mask = soft_mask.filter(ImageFilter.MaxFilter(5))
+    soft_mask = soft_mask.filter(ImageFilter.GaussianBlur(3))
+    
+    # 4. Compositing: Kombiniere Originalbild und bearbeiteten Bereich
+    final_image = original_image.copy()
+    
+    # Konvertiere für alpha blending
+    edited_rgba = edited_region_fullsize.convert("RGBA")
+    soft_mask_rgba = soft_mask.convert("L")
+    
+    # Erstelle ein temporäres Bild mit Alpha-Kanal
+    temp_image = Image.new("RGBA", original_size, (0, 0, 0, 0))
+    temp_image.paste(edited_rgba, (0, 0), soft_mask_rgba)
+    
+    # Kombiniere mit Original
+    final_image = Image.alpha_composite(final_image.convert("RGBA"), temp_image)
+    final_image = final_image.convert("RGB")
+    
+    print(f"✅ Compositing abgeschlossen. Finale Größe: {final_image.size}")
+    
+    return final_image
+
 def auto_detect_face_area(image):
     """Optimierten Vorschlag für Gesichtsbereich ohne externe Bibliotheken"""
     width, height = image.size
@@ -190,7 +321,6 @@ def load_txt2img(model_id):
     """Lädt das Text-to-Image Modell basierend auf der Auswahl"""
     global pipe_txt2img, current_pipe_model_id
     
-    # Wenn bereits das richtige Modell geladen ist, nichts tun
     if pipe_txt2img is not None and current_pipe_model_id == model_id:
         print(f"✅ Modell {model_id} bereits geladen")
         return pipe_txt2img
@@ -217,16 +347,14 @@ def load_txt2img(model_id):
                 print("ℹ️ Versuche ohne VAE weiter...")
                 vae = None
         
-        # Modellparameter basierend auf Modelltyp
         model_params = {
             "torch_dtype": torch_dtype,
             "safety_checker": None,
             "requires_safety_checker": False,
             "add_watermarker": False,
-            "allow_pickle": True,  # Für .bin Modelle wichtig
+            "allow_pickle": True,
         }
         
-        # SAFETENSORS LOGIK
         if model_id in SAFETENSORS_MODELS:
             model_params["use_safetensors"] = True
             print(f"ℹ️ Verwende safetensors für {model_id}")
@@ -234,14 +362,12 @@ def load_txt2img(model_id):
             model_params["use_safetensors"] = False
             print(f"ℹ️ Verwende .bin weights für {model_id}")
         
-        # FP16 Variante nur wenn Modell sie unterstützt UND wir auf GPU sind
         if config.get("supports_fp16", False) and torch_dtype == torch.float16:
             model_params["variant"] = "fp16"
             print("ℹ️ Verwende FP16 Variante")
         else:
             print("ℹ️ Verwende Standard Variante (kein FP16)")
         
-        # VAE nur wenn nicht None
         if vae is not None:
             model_params["vae"] = vae
         
@@ -251,10 +377,8 @@ def load_txt2img(model_id):
             **model_params
         ).to(device)
         
-        # SICHERER SCHEDULER-HANDLING
         print("⚙️ Konfiguriere Scheduler...")
         
-        # Prüfe ob Scheduler existiert
         if pipe_txt2img.scheduler is None:
             print("⚠️ Scheduler ist None, setze Standard-Scheduler")
             pipe_txt2img.scheduler = PNDMScheduler.from_pretrained(
@@ -262,13 +386,10 @@ def load_txt2img(model_id):
                 subfolder="scheduler"
             )
         
-        # Versuche DPM-Solver zu verwenden (bessere Ergebnisse)
         try:
-            # Hole die Scheduler-Konfiguration
             if hasattr(pipe_txt2img.scheduler, 'config'):
                 scheduler_config = pipe_txt2img.scheduler.config
             else:
-                # Fallback-Konfiguration für Scheduler
                 scheduler_config = {
                     "beta_start": 0.00085,
                     "beta_end": 0.012,
@@ -279,7 +400,6 @@ def load_txt2img(model_id):
                 }
                 print("⚠️ Keine Scheduler-Konfig gefunden, verwende Standard")
             
-            # Setze DPM-Solver Scheduler
             pipe_txt2img.scheduler = DPMSolverMultistepScheduler.from_config(
                 scheduler_config,
                 use_karras_sigmas=True,
@@ -291,11 +411,9 @@ def load_txt2img(model_id):
             print(f"⚠️ Konnte DPM-Scheduler nicht setzen: {scheduler_error}")
             print("ℹ️ Verwende Standard-Scheduler weiter")
         
-        # Optimierungen
         pipe_txt2img.enable_attention_slicing()
         print("✅ Attention Slicing aktiviert")
         
-        # VAE Slicing nur wenn VAE existiert
         if hasattr(pipe_txt2img, 'vae') and pipe_txt2img.vae is not None:
             try:
                 pipe_txt2img.enable_vae_slicing()
@@ -319,7 +437,6 @@ def load_txt2img(model_id):
         traceback.print_exc()
         print("🔄 Fallback auf SD 1.5...")
         
-        # Fallback auf Standard SD 1.5
         try:
             pipe_txt2img = StableDiffusionPipeline.from_pretrained(
                 "runwayml/stable-diffusion-v1-5",
@@ -348,7 +465,6 @@ def load_img2img():
                 safety_checker=None,
             ).to(device)
             
-            # WICHTIG: Behalte DPMSolver++ Scheduler bei (beste Qualität für Inpainting)
             pipe_img2img.scheduler = DPMSolverMultistepScheduler.from_config(
                 pipe_img2img.scheduler.config,
                 algorithm_type="sde-dpmsolver++",
@@ -543,114 +659,17 @@ def update_slider_for_image(image):
         gr.update(maximum=max_height)
     )
 
-# === HAUPTFUNKTIONEN (ANGEPASST FÜR 3 MODI) ===
-def text_to_image(prompt, model_id, steps, guidance_scale, progress=gr.Progress()):
-    try:
-        if not prompt or not prompt.strip():
-            return None, "Bitte einen Prompt eingeben"
-            
-        print(f"🚀 Starte Generierung mit Modell: {model_id}")
-        print(f"📝 Prompt: {prompt}")
-        
-        # Automatische negative Prompts generieren
-        auto_negatives = auto_negative_prompt(prompt)
-        print(f"🤖 Automatisch generierte Negative Prompts: {auto_negatives}")
-        
-        start_time = time.time()
-        
-
-        # Liste von Qualitätswörtern/Gewichten, die auf Benutzereingaben prüfen
-        quality_keywords = ['masterpiece', 'best quality', 'high quality', 'highly detailed', 
-                           'exquisite', 'ultra detailed', 'professional', 
-                           'perfect', 'excellent', 'amazing', 'stunning', 'beautiful']
-        
-        # Prüfe, ob der Benutzer bereits Qualitätswörter/Gewichte verwendet hat
-        user_has_quality_words = False
-        
-        # Konvertiere Prompt zu Kleinbuchstaben für die Prüfung
-        prompt_lower = prompt.lower()
-        
-        # Prüfe auf einfache Qualitätswörter
-        for keyword in quality_keywords:
-            if keyword in prompt_lower:
-                user_has_quality_words = True
-                print(f"✓ Benutzer verwendet bereits Qualitätswort: {keyword}")
-                break
-        
-        # Prüfe auf Gewichte (z.B. (word:1.5), [word], etc.)
-        weight_patterns = [r'\([^)]+:\d+(\.\d+)?\)', r'\[[^\]]+\]']
-        for pattern in weight_patterns:
-            if re.search(pattern, prompt):
-                user_has_quality_words = True
-                print("✓ Benutzer verwendet bereits Gewichte im Prompt")
-                break
-        
-        # Prompt basierend auf Prüfung anpassen
-        if not user_has_quality_words:
-            enhanced_prompt = f"masterpiece, best quality, {prompt}"
-            print(f"🔄 Verbesserter Prompt: {enhanced_prompt}")
-        else:
-            enhanced_prompt = prompt
-            print("✓ Benutzerprompt wird unverändert verwendet")
-        
-        print(f"Finaler Prompt für Generation: {enhanced_prompt}")
-
-        
-        
-        progress(0, desc="Lade Modell...")
-        pipe = load_txt2img(model_id)
-        
-        seed = random.randint(0, 2**32 - 1)
-        generator = torch.Generator(device=device).manual_seed(seed)
-        print(f"🌱 Seed: {seed}")
-        
-        callback = TextToImageProgressCallback(progress, steps)
-        
-        print(f"⚙️ Einstellungen: Steps={steps}, CFG={guidance_scale}")
-        
-        image = pipe(
-            prompt=enhanced_prompt,
-            negative_prompt=auto_negatives,
-            height=512,
-            width=512,
-            num_inference_steps=int(steps),
-            guidance_scale=guidance_scale,
-            generator=generator,
-            callback_on_step_end=callback,
-            callback_on_step_end_tensor_inputs=[],
-        ).images[0]
-        
-        end_time = time.time()
-        duration = end_time - start_time
-        print(f"✅ Bild generiert in {duration:.2f} Sekunden")
-        
-        config = MODEL_CONFIGS.get(model_id, MODEL_CONFIGS["runwayml/stable-diffusion-v1-5"])
-        status_msg = f"✅ Generiert mit {config['name']} in {duration:.1f}s"
-        
-        return image, status_msg
-        
-    except Exception as e:
-        error_msg = f"❌ Fehler: {str(e)}"
-        print(f"❌ Fehler in text_to_image: {e}")
-        import traceback
-        traceback.print_exc()
-        return None, error_msg
-
-
+# === KORRIGIERTE HAUPTFUNKTION MIT RICHTIGEM COMPOSITING ===
 def img_to_image(image, prompt, neg_prompt, strength, steps, guidance_scale,
                  mode, bbox_x1, bbox_y1, bbox_x2, bbox_y2,
                  progress=gr.Progress()):
     """
-    HAUPTFUNKTION FÜR BILD-zu-BILD (ANGEPASST FÜR 3 MODI)
+    KORRIGIERTE HAUPTFUNKTION FÜR BILD-zu-BILD MIT RICHTIGEM COMPOSITING
     
-    WICHTIG: Der 'mode' Parameter bestimmt:
-    - "environment_change": Depth + Canny, Maske außen weiß
-    - "focus_change": OpenPose + Canny, Maske innen weiß  
-    - "face_only_change": Depth + Canny, Maske innen weiß
-    
-    keep_environment Parameter für ControlNet:
-    - True für "environment_change" und "face_only_change" (Depth+Canny)
-    - False für "focus_change" (OpenPose+Canny)
+    WICHTIG: Verwendet den korrekten Compositing-Workflow:
+    1. Skaliert Bild und Maske gemeinsam
+    2. Führt Inpainting auf 512×512 durch
+    3. Kompositiert nur den bearbeiteten Bereich zurück ins Originalbild
     """
     try:
         if image is None:
@@ -664,8 +683,7 @@ def img_to_image(image, prompt, neg_prompt, strength, steps, guidance_scale,
         print(f"📝 Prompt: {prompt}")
         print(f"🚫 Negativ-Prompt: {neg_prompt}")
         
-
-                 # ===== AUTOMATISCHEN NEGATIV-PROMPT GENERIEREN =====
+        # ===== AUTOMATISCHEN NEGATIV-PROMPT GENERIEREN =====
         auto_negatives = auto_negative_prompt(prompt)
         print(f"🤖 Automatisch generierter Negativ-Prompt: {auto_negatives}")
         
@@ -673,23 +691,18 @@ def img_to_image(image, prompt, neg_prompt, strength, steps, guidance_scale,
         combined_negative_prompt = ""
         
         if neg_prompt and neg_prompt.strip():
-            # Benutzer hat einen Negativ-Prompt eingegeben
             user_neg = neg_prompt.strip()
             print(f"👤 Benutzer Negativ-Prompt: {user_neg}")
             
-            # Entferne Duplikate zwischen automatischen und manuellen Prompts
             user_words = [word.strip().lower() for word in user_neg.split(",")]
             auto_words = [word.strip().lower() for word in auto_negatives.split(",")]
             
-            # Starte mit dem Benutzer-Prompt
             combined_words = user_words.copy()
             
-            # Füge automatische Wörter hinzu, die nicht bereits vorhanden sind
             for auto_word in auto_words:
                 if auto_word and auto_word not in user_words:
                     combined_words.append(auto_word)
             
-            # Zusammenfügen und Duplikate entfernen
             unique_words = []
             seen_words = set()
             for word in combined_words:
@@ -699,19 +712,15 @@ def img_to_image(image, prompt, neg_prompt, strength, steps, guidance_scale,
             
             combined_negative_prompt = ", ".join(unique_words)
         else:
-            # Kein Benutzer-Prompt, verwende nur den automatischen
             combined_negative_prompt = auto_negatives
             print(f"ℹ️ Kein manueller Negativ-Prompt, verwende nur automatischen: {combined_negative_prompt}")
         
         print(f"✅ Finaler kombinierter Negativ-Prompt: {combined_negative_prompt}")
 
-
         # ===== GESICHTS-SPEZIFISCHE BOOSTER FÜR NUR-GESICHT MODUS =====
         if mode == "face_only_change":
-            # Gesichtsspezifische Booster hinzufügen
             face_boosters = "(perfect face:1.2), (symmetrical face:1.1), realistic shaded perfect face, "
             
-            # Prüfen ob Prompts schon gewichtete Face-Booster haben
             if not any(keyword in prompt.lower() for keyword in 
                    ["perfect face", "symmetrical", "realistic face", "shaded face"]):
                 enhanced_prompt = face_boosters + prompt
@@ -720,15 +729,12 @@ def img_to_image(image, prompt, neg_prompt, strength, steps, guidance_scale,
                 enhanced_prompt = prompt
                 print(f"👤 Benutzer hat bereits Gesichts-Booster im Prompt")
         else:
-            # Für andere Modi: Normaler Prompt
             enhanced_prompt = prompt
 
         # ===== HINTERGRUND-BOOSTER FÜR UMGEBUNGS-ÄNDERUNG =====
         if mode == "environment_change":
-            # Booster für komplett neue Umgebung
             background_boosters = "complete scene, full background, entire environment, "
             
-            # Prüfe ob schon Booster enthalten
             if not any(keyword in enhanced_prompt.lower() for keyword in 
                       ["complete scene", "full background", "entire environment", "whole setting"]):
                 enhanced_prompt = background_boosters + enhanced_prompt
@@ -736,34 +742,24 @@ def img_to_image(image, prompt, neg_prompt, strength, steps, guidance_scale,
 
         print(f"🎯 Finaler Prompt für {mode}: {enhanced_prompt}")
 
-
         progress(0, desc="Starte Generierung mit ControlNet...")
 
-
         # ===== MODUS-SPEZIFISCHE EINSTELLUNGEN =====
         adj_strength = min(0.85, strength * 1.25)
 
-        #controlnet_strength zwischen 0.15-0.255 ->prompt dominiert
-        #controlnet_strength zwischen 0.35-0.595 → ControlNet dominiert (Prompt begrenzt)
-        #controlnet_strength zwischen 0.25-0.425 → Balance (50/50)
-        
-        # Bestimme keep_environment basierend auf Modus
         if mode == "focus_change":
-            # MODUS 2: Focus verändern → OpenPose + Canny
             keep_environment = False
-            controlnet_strength = adj_strength * 0.7  # Höher für Strukturerhalt 
+            controlnet_strength = adj_strength * 0.7
             print(f"🎯 MODUS: Focus verändern → OpenPose+Canny (keep_environment=False)")
             
         elif mode == "environment_change":
-            # MODUS 1: Umgebung ändern → Depth + Canny
             keep_environment = True
-            controlnet_strength = adj_strength * 0.3  # NIEDRIG für radikale Änderungen
+            controlnet_strength = adj_strength * 0.3
             print(f"🎯 MODUS: Umgebung ändern → Depth+Canny (keep_environment=True)")
             
         else:  # face_only_change
-            # MODUS 3: Ausschließlich Gesicht → Depth + Canny
             keep_environment = True
-            controlnet_strength = adj_strength * 0.5  # Balance für Gesichtsdetails
+            controlnet_strength = adj_strength * 0.5
             print(f"🎯 MODUS: Ausschließlich Gesicht → Depth+Canny (keep_environment=True)")
             
         controlnet_steps = min(25, int(steps * 0.8))
@@ -771,64 +767,89 @@ def img_to_image(image, prompt, neg_prompt, strength, steps, guidance_scale,
 
         progress(0.03, desc="ControlNet läuft...")
 
+        # ===== WICHTIG: VARIABLEN FÜR KOMPLETTEN WORKFLOW =====
+        original_mask = None
+        padding_info = None
+        controlnet_input = image.convert("RGB")  # Standard: Originalbild
+        
+        if bbox_x1 is not None and bbox_y1 is not None and bbox_x2 is not None and bbox_y2 is not None:
+            print(f"🎯 BBox Koordinaten erhalten: [{bbox_x1}, {bbox_y1}, {bbox_x2}, {bbox_y2}]")
+            
+            # 1. MASKE AUF ORIGINAL-BILD ERSTELLEN (speichern für späteres Compositing)
+            original_mask = create_face_mask(image, (bbox_x1, bbox_y1, bbox_x2, bbox_y2), mode)
+            
+            # 2. BILD UND MASKE GEMEINSAM SKALIEREN (mit Padding)
+            scaled_image, scaled_mask, padding_info = scale_image_and_mask_together(
+                image.convert("RGB"),  # Originalbild
+                original_mask,          # Originalmaske
+                target_size=IMG_SIZE
+            )
+            
+            controlnet_input = scaled_image  # Verwende das skalierte Bild für ControlNet
+            print(f"✅ Gemeinsame Skalierung abgeschlossen")
+            print(f"   Original: {image.size} → Skaliert: {scaled_image.size}")
+        else:
+            # Keine BBox: Normales Img2Img (ohne Maske)
+            print(f"ℹ️ Keine BBox angegeben → normales Img2Img (ohne Maske)")
+            controlnet_input = image.convert("RGB").resize((IMG_SIZE, IMG_SIZE), Image.Resampling.LANCZOS)
+
         # ===== CONTROLNET AUFRUF =====
+        print(f"📊 ControlNet Input Größe: {controlnet_input.size}")
+        
         controlnet_output, inpaint_input = controlnet_processor.generate_with_controlnet(
-            image=image,
-            prompt=enhanced_prompt,  # WICHTIG: enhanced_prompt verwenden!
+            image=controlnet_input,
+            prompt=enhanced_prompt,
             negative_prompt=combined_negative_prompt,
             steps=controlnet_steps,
             guidance_scale=guidance_scale,
             controlnet_strength=controlnet_strength,
-            progress=None,  # kein Progress an ControlNet
+            progress=None,
             keep_environment=keep_environment
         )
 
-        print(f"✅ ControlNet Output erhalten: {type(controlnet_output)}")
-        print(f"✅ Inpaint Input erhalten: {type(inpaint_input)}")
+        print(f"✅ ControlNet Output erhalten")
+        print(f"✅ Inpaint Input Größe: {inpaint_input.size}")
 
         progress(0.3, desc="ControlNet abgeschlossen – starte Inpaint...")
 
+        # ===== INPAINTING PIPELINE =====
         pipe = load_img2img()
         
-        # ===== RICHTIGE BILD-SKALIERUNG =====
-        # Prüfe ob ControlNet schon 512×512 liefert
-        if inpaint_input.size != (512, 512):
-            img_resized = inpaint_input.convert("RGB").resize((512, 512), Image.Resampling.LANCZOS)
-            print("🔄 ControlNet Output von {} auf 512×512 skaliert".format(inpaint_input.size))
+        # Bild für Inpainting vorbereiten
+        if inpaint_input.size != (IMG_SIZE, IMG_SIZE):
+            print(f"⚠️ Inpaint Input hat unerwartete Größe {inpaint_input.size}, skaliere auf {IMG_SIZE}x{IMG_SIZE}")
+            img_resized = inpaint_input.convert("RGB").resize((IMG_SIZE, IMG_SIZE), Image.Resampling.LANCZOS)
         else:
             img_resized = inpaint_input.convert("RGB")
-            print("✅ ControlNet Output ist bereits 512×512")
+            print(f"✅ Inpaint Input ist bereits {IMG_SIZE}x{IMG_SIZE}")
 
+        # ===== SEED UND GENERATOR =====
         adj_guidance = min(guidance_scale, 12.0)
         seed = random.randint(0, 2**32 - 1)
         generator = torch.Generator(device=device).manual_seed(seed)
         print(f"🌱 Inpaint Seed: {seed}")
 
-        # ===== RICHTIGE MASKEN-ERSTELLUNG (FIX: KEINE DOPPELTE SKALIERUNG) =====
-        mask = 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:
-            # 1. Maske AUF ORIGINAL-BILD erstellen (korrekte Proportionen)
-            original_mask = create_face_mask(image, (bbox_x1, bbox_y1, bbox_x2, bbox_y2), mode)
-            
-            # 2. Maske auf 512×512 skalieren (gleicher Algorithmus wie Bild)
-            # WICHTIG: NEAREST für scharfe Kanten, da Maske binär ist
-            mask = original_mask.resize((512, 512), Image.Resampling.NEAREST)
-            
-            print(f"✅ Maske erstellt für Modus: {mode}")
-            print(f"   Original BBox: [{bbox_x1}, {bbox_y1}, {bbox_x2}, {bbox_y2}]")
-            print(f"   Maske skaliert von {original_mask.size} auf {mask.size}")
-
-        # WICHTIG: KEINE SCHEDULER-ÄNDERUNG MEHR - DPMSolver++ bleibt aktiv
-        print(f"✅ Verwende DPMSolver++ Scheduler: {type(pipe.scheduler).__name__}")
+        # ===== MASKE FÜR INPAINTING VORBEREITEN =====
+        inpaint_mask = None
+        if original_mask is not None and padding_info is not None:
+            # Verwende die skalierte Maske für Inpainting
+            _, scaled_mask, _ = scale_image_and_mask_together(
+                image.convert("RGB"),
+                original_mask,
+                target_size=IMG_SIZE
+            )
+            inpaint_mask = scaled_mask
+            print(f"✅ Maske für Inpainting vorbereitet: {inpaint_mask.size}")
 
+        # ===== FORTSCHRITTS-CALLBACK =====
         callback = ImageToImageProgressCallback(progress, int(steps), adj_strength)
 
         # ===== INPAINT DURCHFÜHREN =====
         result = pipe(
-            prompt=enhanced_prompt,  # WICHTIG: enhanced_prompt verwenden!
+            prompt=enhanced_prompt,
             negative_prompt=combined_negative_prompt,
             image=img_resized,
-            mask_image=mask,
+            mask_image=inpaint_mask,
             strength=adj_strength,
             num_inference_steps=int(steps),
             guidance_scale=adj_guidance,
@@ -837,21 +858,38 @@ def img_to_image(image, prompt, neg_prompt, strength, steps, guidance_scale,
             callback_on_step_end_tensor_inputs=[],
         )
 
+        # ===== KORREKTES COMPOSITING =====
+        generated_image = result.images[0]
+        
+        if original_mask is not None and padding_info is not None:
+            # KORREKTER WORKFLOW: Nur bearbeiteten Bereich in Originalbild einfügen
+            final_image = composite_edited_region(
+                original_image=image.convert("RGB"),
+                inpaint_result=generated_image,
+                original_mask=original_mask,
+                padding_info=padding_info
+            )
+            print(f"✅ Korrektes Compositing durchgeführt")
+        else:
+            # Keine Maske: Einfach das generierte Bild zurückgeben (bereits 512×512)
+            final_image = generated_image
+            print(f"ℹ️ Keine Maske → Direkte Rückgabe des 512×512 Bildes")
+
         end_time = time.time()
         duration = end_time - start_time
+        
         print(f"✅ Transformation abgeschlossen in {duration:.2f} Sekunden")
         print(f"🎯 Verwendeter Modus: {mode}")
         print(f"⚙️ ControlNet: {'Depth+Canny' if keep_environment else 'OpenPose+Canny'}")
-        print(f"⚙️ Scheduler: DPMSolver++ (optimal für Inpainting)")
+        print(f"📊 Finale Bildgröße: {final_image.size}")
 
-        generated_image = result.images[0]
-        return generated_image
+        return final_image
 
     except Exception as e:
         print(f"❌ Fehler in img_to_image: {e}")
         import traceback
         traceback.print_exc()
-        return None  
+        return None
 
 def update_bbox_from_image(image):
     """Aktualisiert die Bounding-Box-Koordinaten wenn ein Bild hochgeladen wird"""
@@ -874,7 +912,6 @@ def update_model_settings(model_id):
 def main_ui():
     """
     HAUPT-UI (ANGEPASST FÜR 3 MODI)
-    Wichtigste Änderung: Ersetzung der Checkbox durch Radio-Buttons
     """
     with gr.Blocks(
         title="AI Image Generator", 
@@ -1212,7 +1249,8 @@ def main_ui():
                      "• **🆕 Dynamische Koordinaten-Schieberegler** passen sich an Bildgröße an\n"
                      "• **ControlNet-Technologie** für konsistente Ergebnisse\n"
                      "• **Automatische Negative Prompts** für bessere Qualität\n"
-                     "• **Ausgabe immer 512×512 Pixel** für beste Kontrolle"
+                     "• **KORREKTER COMPOSITING-WORKFLOW** – nur bearbeiteter Bereich wird eingefügt\n"
+                     "• **Ausgabe: 512×512 Pixel** für beste Qualität (kein Hochskalieren!)"
                     )
                 
                 transform_btn = gr.Button("🔄 Bild transformieren", variant="primary")
@@ -1277,5 +1315,5 @@ if __name__ == "__main__":
         max_file_size="15MB",
         show_error=True,
         share=False,
-        ssr_mode=False  # SSR deaktivieren für Stabilität
+        ssr_mode=False
     )