Update app.py

app.py

@@ -15,6 +15,7 @@ import re
 device = "cuda" if torch.cuda.is_available() else "cpu"
 torch_dtype = torch.float16 if device == "cuda" else torch.float32
 IMG_SIZE = 512
+MAX_IMAGE_SIZE = 4096  # Maximale Bildgröße für Verarbeitung
 
 print(f"Running on: {device}")
 
@@ -104,6 +105,15 @@ def auto_negative_prompt(positive_prompt):
     else:
         return base_negatives
 
+# === HILFSFUNKTION: KOORDINATEN SORTIEREN ===
+def sort_coordinates(x1, y1, x2, y2):
+    """Sortiert Koordinaten, so dass x1 <= x2 und y1 <= y2"""
+    sorted_x1 = min(x1, x2)
+    sorted_x2 = max(x1, x2)
+    sorted_y1 = min(y1, y2)
+    sorted_y2 = max(y1, y2)
+    return sorted_x1, sorted_y1, sorted_x2, sorted_y2
+
 # === GESICHTSMASKEN-FUNKTIONEN (ERWEITERT FÜR 3 MODI) ===
 def create_face_mask(image, bbox_coords, mode):
     """
@@ -121,44 +131,54 @@ def create_face_mask(image, bbox_coords, mode):
     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
+        # Sortiere Koordinaten
+        x1, y1, x2, y2 = sort_coordinates(*bbox_coords)
+        
+        # Stelle sicher, dass Koordinaten innerhalb des Bildes liegen
+        x1 = max(0, min(x1, image.width-1))
+        y1 = max(0, min(y1, image.height-1))
+        x2 = max(0, min(x2, image.width-1))
+        y2 = max(0, min(y2, image.height-1))
+        
         draw = ImageDraw.Draw(mask)
         
         if mode == "environment_change":
             # MODUS 1: Umgebung ändern (Depth + Canny)
-            # Maske: Alles weiß AUSSER Gesicht (schwarz)
+            # Maske: Alles weiß AUSSER Bereich (schwarz)
             draw.rectangle([0, 0, image.size[0], image.size[1]], fill=255)  # Alles weiß = verändern
-            draw.rectangle([x1, y1, x2, y2], fill=0)  # Gesicht schwarz = geschützt (rechteckig)
-            print("🎯 MODUS: Umgebung ändern - Alles außer Gesicht wird verändert")
+            draw.rectangle([x1, y1, x2, y2], fill=0)  # Bereich schwarz = geschützt (rechteckig)
+            print(f"🎯 MODUS: Umgebung ändern - Alles außer BBox wird verändert (BBox: {x1},{y1},{x2},{y2})")
             
         elif mode == "focus_change":
             # MODUS 2: Focus verändern (OpenPose + Canny)
             # Maske: Nur innerhalb der Box weiß (Rest schwarz)
             draw.rectangle([x1, y1, x2, y2], fill=255)  # Nur Box weiß = verändern
-            print("🎯 MODUS: Focus verändern - Nur innerhalb der Box wird verändert")
+            print(f"🎯 MODUS: Focus verändern - Nur innerhalb der BBox wird verändert (BBox: {x1},{y1},{x2},{y2})")
             
         elif mode == "face_only_change":
             # MODUS 3: Ausschließlich Gesicht (Depth + Canny)
             # Maske: Nur innerhalb der Box weiß (Rest schwarz) - wie focus_change
             draw.rectangle([x1, y1, x2, y2], fill=255)  # Nur Box weiß = verändern
-            print("🎯 MODUS: Ausschließlich Gesicht - Nur Gesicht wird verändert")
+            print(f"🎯 MODUS: Ausschließlich Gesicht - Nur innerhalb der BBox wird verändert (BBox: {x1},{y1},{x2},{y2})")
     
     return mask
 
 def auto_detect_face_area(image):
     """Optimierten Vorschlag für Gesichtsbereich ohne externe Bibliotheken"""
     width, height = image.size
-    # Größere Bounding Box für bessere Abdeckung (50% statt 40%)
     face_size = min(width, height) * 0.4
-    # Verschiebe y1 nach oben, um Stirn und Kinn besser abzudecken
     x1 = (width - face_size) / 2
-    y1 = (height - face_size) / 4  # Höher positioniert (25% statt 33%)
+    y1 = (height - face_size) / 4
     x2 = x1 + face_size
-    y2 = y1 + face_size * 1.2  # Leicht länglicher für ovale Gesichter
-    # Stelle sicher, dass Koordinaten innerhalb des Bildes liegen
-    x1, y1 = max(0, int(x1)), max(0, int(y1))
-    x2, y2 = min(width, int(x2)), min(height, int(y2))
-    print(f"Geschätzte Gesichtskoordinaten: [{x1}, {y1}, {x2}, {y2}]")
+    y2 = y1 + face_size * 1.2
+    
+    # Sortiere Koordinaten und stelle sicher, dass sie innerhalb des Bildes liegen
+    x1 = max(0, int(min(x1, x2)))
+    y1 = max(0, int(min(y1, y2)))
+    x2 = min(width, int(max(x1, x2)))
+    y2 = min(height, int(max(y1, y2)))
+    
+    print(f"Geschätzte Gesichtskoordinaten: [{x1}, {y1}, {x2}, {y2}] (Bild: {width}x{height})")
     return [x1, y1, x2, y2]
 
 # === PIPELINES ===
@@ -403,19 +423,19 @@ def create_preview_image(image, bbox_coords, mode):
     # Farben basierend auf Modus
     if mode == "environment_change":
         border_color = (0, 255, 0, 180)  # Grün für Umgebung
-        mode_text = "UMGEBUNG ÄNDERN (Gesicht geschützt)"
-        box_color = (255, 255, 0, 200)  # Gelb für geschütztes Gesicht
+        mode_text = "UMGEBUNG ÄNDERN (Bereich geschützt)"
+        box_color = (255, 255, 0, 200)  # Gelb für geschützten Bereich
         text_bg_color = (0, 128, 0, 160)  # Dunkelgrün
         
     elif mode == "focus_change":
         border_color = (255, 165, 0, 180)  # Orange für Focus
-        mode_text = "FOCUS VERÄNDERN (Gesicht+Körper)"
+        mode_text = "FOCUS VERÄNDERN (Bereich+Körper)"
         box_color = (255, 0, 0, 200)  # Rot für Veränderungsbereich
         text_bg_color = (255, 140, 0, 160)  # Dunkelorange
         
     elif mode == "face_only_change":
         border_color = (255, 0, 0, 180)  # Rot für nur Gesicht
-        mode_text = "NUR GESICHT VERÄNDERN"
+        mode_text = "NUR BEREICH VERÄNDERN"
         box_color = (255, 0, 0, 200)  # Rot für Veränderungsbereich
         text_bg_color = (128, 0, 0, 160)  # Dunkelrot
     else:
@@ -425,27 +445,36 @@ def create_preview_image(image, bbox_coords, mode):
         box_color = (128, 128, 128, 200)
         text_bg_color = (64, 64, 64, 160)
     
-    # Rahmen um das gesamte Bild
-    border_width = 8
+    # Skaliere Rahmendicke basierend auf Bildgröße
+    border_width = max(8, image.width // 200)  # Mindestens 8px, bei großen Bildern dicker
     draw.rectangle([0, 0, preview.width-1, preview.height-1], 
                   outline=border_color, width=border_width)
     
     if bbox_coords and all(coord is not None for coord in bbox_coords):
-        x1, y1, x2, y2 = bbox_coords
-        
-        # Bounding Box zeichnen
-        draw.rectangle([x1, y1, x2, y2], outline=box_color, width=3)
+        # Sortiere Koordinaten
+        x1, y1, x2, y2 = sort_coordinates(*bbox_coords)
         
-        # Modus-Text anzeigen
-        text_color = (255, 255, 255)
+        # Stelle sicher, dass die Koordinaten innerhalb des Bildes liegen
+        x1 = max(0, min(x1, preview.width-1))
+        y1 = max(0, min(y1, preview.height-1))
+        x2 = max(0, min(x2, preview.width-1))
+        y2 = max(0, min(y2, preview.height-1))
         
-        # Text-Hintergrund zeichnen
-        text_bbox = draw.textbbox((x1, y1 - 25), mode_text)
-        draw.rectangle([text_bbox[0]-5, text_bbox[1]-2, text_bbox[2]+5, text_bbox[3]+2], 
-                      fill=text_bg_color)
-        
-        # Text zeichnen
-        draw.text((x1, y1 - 25), mode_text, fill=text_color)
+        # Nur zeichnen, wenn die Bounding Box gültig ist
+        if x2 > x1 and y2 > y1:
+            # Skaliere Box-Rahmen basierend auf Bildgröße
+            box_width = max(3, image.width // 400)
+            draw.rectangle([x1, y1, x2, y2], outline=box_color, width=box_width)
+            
+            text_color = (255, 255, 255)
+            
+            # Text über der Bounding Box platzieren
+            text_y = max(0, y1 - 25)
+            text_bbox = draw.textbbox((x1, text_y), mode_text)
+            draw.rectangle([text_bbox[0]-5, text_bbox[1]-2, text_bbox[2]+5, text_bbox[3]+2], 
+                          fill=text_bg_color)
+            
+            draw.text((x1, text_y), mode_text, fill=text_color)
     
     return preview
 
@@ -457,7 +486,8 @@ def update_live_preview(image, bbox_x1, bbox_y1, bbox_x2, bbox_y2, mode):
     if image is None:
         return None
     
-    bbox_coords = [bbox_x1, bbox_y1, bbox_x2, bbox_y2]
+    # Sortiere die Koordinaten (Slider zeigen Originalkoordinaten)
+    bbox_coords = sort_coordinates(bbox_x1, bbox_y1, bbox_x2, bbox_y2)
     
     return create_preview_image(image, bbox_coords, mode)
 
@@ -466,18 +496,48 @@ def process_image_upload(image):
     if image is None:
         return None, None, None, None, None
 
-    if image.size != (512, 512):
-        image = image.resize((512, 512), Image.LANCZOS)
-        print(f"Bild auf 512x512 skaliert")  
+    width, height = image.size
     
+    # Berechne Bounding-Box basierend auf der tatsächlichen Bildgröße
     bbox = auto_detect_face_area(image)
-    bbox_x1, bbox_y1, bbox_x2, bbox_y2 = bbox
     
-    # Standardmodus: "environment_change" (Umgebung ändern)
-    preview = create_preview_image(image, bbox, "environment_change")
+    # Sortiere die Koordinaten
+    bbox_x1, bbox_y1, bbox_x2, bbox_y2 = sort_coordinates(*bbox)
+    
+    # Für die Vorschau verwende die Originalkoordinaten
+    preview = create_preview_image(image, [bbox_x1, bbox_y1, bbox_x2, bbox_y2], "environment_change")
+    
+    # Slider-Werte SIND JETZT ORIGINALKOORDINATEN (keine 512-Skalierung!)
+    print(f"Bild {width}x{height} -> Slider-Originalwerte: [{bbox_x1}, {bbox_y1}, {bbox_x2}, {bbox_y2}]")
     
     return preview, bbox_x1, bbox_y1, bbox_x2, bbox_y2
 
+# === FUNKTION FÜR SLIDER-UPDATE ===
+def update_slider_for_image(image):
+    """Aktualisiert Slider-Maxima basierend auf Bildgröße bis 4096x4096"""
+    if image is None:
+        return (
+            gr.update(maximum=MAX_IMAGE_SIZE),
+            gr.update(maximum=MAX_IMAGE_SIZE),
+            gr.update(maximum=MAX_IMAGE_SIZE),
+            gr.update(maximum=MAX_IMAGE_SIZE)
+        )
+    
+    width, height = image.size
+    
+    # Setze Slider-Maxima auf Bildgröße (begrenzt auf MAX_IMAGE_SIZE für Stabilität)
+    max_width = min(width, MAX_IMAGE_SIZE)
+    max_height = min(height, MAX_IMAGE_SIZE)
+    
+    print(f"Slider-Maxima gesetzt auf: {max_width}x{max_height}")
+    
+    return (
+        gr.update(maximum=max_width),
+        gr.update(maximum=max_height),
+        gr.update(maximum=max_width),
+        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:
@@ -693,23 +753,34 @@ def img_to_image(image, prompt, neg_prompt, strength, steps, guidance_scale,
 
         # ===== MASKE ERSTELLEN (BASIEREND AUF MODUS) =====
         mask = None
-        if bbox_x1 and bbox_y1 and bbox_x2 and bbox_y2:
-            orig_w, orig_h = image.size
-            scale_x, scale_y = 512 / orig_w, 512 / orig_h
-            bbox_coords = [
-                int(bbox_x1 * scale_x),
-                int(bbox_y1 * scale_y),
-                int(bbox_x2 * scale_x),
-                int(bbox_y2 * scale_y)
-            ]
-            print(f"📐 Skalierte Koordinaten: {bbox_coords}")
+        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 Slider-Werte (Original-Bildgröße) auf 512x512 für die Pipeline
+            width, height = image.size
             
-            # NEU: Modus-spezifische Maskenerstellung
-            mask = create_face_mask(img_resized, bbox_coords, mode)
+            # Skalierungsfaktoren berechnen
+            scale_x = IMG_SIZE / width
+            scale_y = IMG_SIZE / height
+            
+            # Skaliere Bounding-Box-Koordinaten auf 512x512
+            pipeline_x1 = int(bbox_x1 * scale_x)
+            pipeline_y1 = int(bbox_y1 * scale_y)
+            pipeline_x2 = int(bbox_x2 * scale_x)
+            pipeline_y2 = int(bbox_y2 * scale_y)
+            
+            # Sortiere und begrenze die Koordinaten
+            pipeline_bbox = sort_coordinates(
+                max(0, min(pipeline_x1, IMG_SIZE-1)),
+                max(0, min(pipeline_y1, IMG_SIZE-1)),
+                max(0, min(pipeline_x2, IMG_SIZE-1)),
+                max(0, min(pipeline_y2, IMG_SIZE-1))
+            )
+            
+            print(f"Original BBox: [{bbox_x1}, {bbox_y1}, {bbox_x2}, {bbox_y2}] -> Pipeline BBox: {pipeline_bbox}")
+            
+            # Erstelle Maske basierend auf skalierten Koordinaten
+            mask = create_face_mask(img_resized, pipeline_bbox, mode)
             if mask:
                 print(f"✅ Maske erstellt für Modus: {mode}")
-        else:
-            print("⚠️ Keine gültigen Koordinaten – keine Maske")
 
         from diffusers import EulerAncestralDiscreteScheduler
         if not isinstance(pipe.scheduler, EulerAncestralDiscreteScheduler):
@@ -1022,39 +1093,40 @@ def main_ui():
                         gr.Markdown("""
                         <div style="font-size: 12px; color: #666; margin-top: 10px;">
                         <strong>Modus-Erklärungen:</strong><br>
-                        • <strong>🌳 Umgebung ändern:</strong> Ändert alles AUSSER dem Gesicht (Depth+Canny)<br>
-                        • <strong>🎯 Focus verändern:</strong> Ändert Gesicht+Körper (OpenPose+Canny)<br>
-                        • <strong>👤 Ausschließlich Gesicht:</strong> Ändert NUR das Gesicht (Depth+Canny)
+                        • <strong>🌳 Umgebung ändern:</strong> Ändert alles AUSSER dem markierten Bereich (Depth+Canny)<br>
+                        • <strong>🎯 Focus verändern:</strong> Ändert markierten Bereich+Körper (OpenPose+Canny)<br>
+                        • <strong>👤 Ausschließlich Gesicht:</strong> Ändert NUR den markierten Bereich (Depth+Canny)
                         </div>
                         """)
                 
                 with gr.Row():
                     gr.Markdown("### 📐 Bildelementbereich anpassen")
                 
+                # SLIDER MIT DYNAMISCHEM MAXIMUM (4096 für große Bilder)
                 with gr.Row():
                     with gr.Column():
                         bbox_x1 = gr.Slider(
                             label="← Links (x1)", 
-                            minimum=0, maximum=512, value=100, step=1,
+                            minimum=0, maximum=MAX_IMAGE_SIZE, value=100, step=1,
                             info="Linke Kante des Bildelementbereichs"
                         )
                     with gr.Column():
                         bbox_y1 = gr.Slider(
                             label="↑ Oben (y1)", 
-                            minimum=0, maximum=512, value=100, step=1,
+                            minimum=0, maximum=MAX_IMAGE_SIZE, value=100, step=1,
                             info="Obere Kante des Bildelementbereichs"
                         )
                 with gr.Row():
                     with gr.Column():
                         bbox_x2 = gr.Slider(
                             label="→ Rechts (x2)", 
-                            minimum=0, maximum=512, value=300, step=1,
+                            minimum=0, maximum=MAX_IMAGE_SIZE, value=300, step=1,
                             info="Rechte Kante des Bildelementbereichs"
                         )
                     with gr.Column():
                         bbox_y2 = gr.Slider(
                             label="↓ Unten (y2)", 
-                            minimum=0, maximum=512, value=300, step=1,
+                            minimum=0, maximum=MAX_IMAGE_SIZE, value=300, step=1,
                             info="Untere Kante des Bildelementbereichs"
                         )
                 
@@ -1098,27 +1170,34 @@ def main_ui():
                    gr.Markdown(
                      "### 📋 Hinweise:\n"
                      "• **🆕 3 Transformations-Modi** für präzise Kontrolle\n"
+                     "• **🆕 Unterstützt Bilder bis 4096×4096 Pixel**\n"
                      "• **🆕 Automatische Bildelementerkennung** setzt Koordinaten beim Upload\n"  
                      "• **🆕 Live-Vorschau** zeigt farbige Rahmen je nach Modus\n"
-                     "• **🆕 Koordinaten-Schieberegler** für präzise Anpassung mit Live-Update\n"
+                     "• **🆕 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"
+                     "• **Automatische Negative Prompts** für bessere Qualität\n"
+                     "• **Ausgabe immer 512×512 Pixel** für beste Kontrolle"
                     )
                 
                 transform_btn = gr.Button("🔄 Bild transformieren", variant="primary")
                 
                 with gr.Row():
                     img_output = gr.Image(
-                        label="✨ Transformiertes Bild",
+                        label="✨ Transformiertes Bild (512×512 - SD-Technologie-Limit)",
                         show_download_button=True,
                         type="pil",
                         height=400
                     )
                 
+                # EVENT-HANDLER FÜR DYNAMISCHE BILDGRÖßEN
                 img_input.change(
                     fn=process_image_upload,
                     inputs=[img_input],
                     outputs=[preview_output, bbox_x1, bbox_y1, bbox_x2, bbox_y2]
+                ).then(
+                    fn=update_slider_for_image,
+                    inputs=[img_input],
+                    outputs=[bbox_x1, bbox_y1, bbox_x2, bbox_y2]
                 )
                 
                 # NEUE Input-Liste mit mode_radio statt face_preserve
@@ -1159,7 +1238,7 @@ if __name__ == "__main__":
     demo.launch(
         server_name="0.0.0.0", 
         server_port=7860,
-        max_file_size="10MB",
+        max_file_size="15MB",
         show_error=True,
         share=False,
         ssr_mode=False  # SSR deaktivieren für Stabilität