Update text_integration.py

text_integration.py

@@ -1,6 +1,66 @@
 from PIL import Image, ImageDraw, ImageFont
 import gradio as gr
 import numpy as np
+import os
+import requests
+import tempfile
+
+# URLs zu freien Schriftarten auf GitHub
+FONT_URLS = {
+    "Roboto": "https://github.com/google/fonts/raw/main/apache/roboto/Roboto-Regular.ttf",
+    "Open Sans": "https://github.com/google/fonts/raw/main/apache/opensans/OpenSans-Regular.ttf",
+    "DejaVu Sans": "https://github.com/dejavu-fonts/dejavu-fonts/raw/master/ttf/DejaVuSans.ttf"
+}
+
+def download_font(font_name):
+    """Lädt eine Schriftart von GitHub herunter und gibt den lokalen Pfad zurück"""
+    try:
+        if font_name not in FONT_URLS:
+            return None
+            
+        # Temporäre Datei erstellen
+        temp_dir = tempfile.gettempdir()
+        font_path = os.path.join(temp_dir, f"{font_name.replace(' ', '_')}.ttf")
+        
+        # Wenn bereits vorhanden, wiederverwenden
+        if os.path.exists(font_path):
+            print(f"✅ Schriftart bereits vorhanden: {font_path}")
+            return font_path
+        
+        # Schriftart von GitHub downloaden
+        print(f"⬇️ Lade Schriftart herunter: {font_name}")
+        response = requests.get(FONT_URLS[font_name], timeout=30)
+        response.raise_for_status()
+        
+        # Schriftart speichern
+        with open(font_path, 'wb') as f:
+            f.write(response.content)
+        
+        print(f"✅ Schriftart heruntergeladen: {font_path}")
+        return font_path
+        
+    except Exception as e:
+        print(f"❌ Fehler beim Download von {font_name}: {e}")
+        return None
+
+def get_available_font():
+    """Gibt eine verfügbare Schriftart zurück (Download falls nötig)"""
+    # Versuche zuerst Roboto
+    roboto_path = download_font("Roboto")
+    if roboto_path:
+        return roboto_path
+    
+    # Fallback zu Open Sans
+    open_sans_path = download_font("Open Sans")
+    if open_sans_path:
+        return open_sans_path
+        
+    # Letzter Fallback zu DejaVu Sans
+    dejavu_path = download_font("DejaVu Sans")
+    if dejavu_path:
+        return dejavu_path
+        
+    return None
 
 def add_text_to_image(image, text, text_x, text_y, font_size="80px", font_family="Roboto", font_color="Weiß"):
     """Fügt Text mit PIL zum Bild hinzu mit Formatierungsoptionen"""
@@ -15,14 +75,14 @@ def add_text_to_image(image, text, text_x, text_y, font_size="80px", font_family
         image_with_text = image.copy()
         draw = ImageDraw.Draw(image_with_text)
         
-        # Schriftgröße direkt aus dem Dropdown-Wert extrahieren (z.B. "80px" -> 80)
+        # Schriftgröße direkt aus dem Dropdown-Wert extrahieren
         try:
             pixel_size = int(font_size.replace("px", ""))
             print(f"Schriftgröße direkt: {font_size} -> {pixel_size}px")
         except:
-            pixel_size = 80  # Fallback
+            pixel_size = 80
         
-        # Schriftfarbe Mapping - schwarz, weiß, rot
+        # Schriftfarbe Mapping
         color_mapping = {
             "Weiß": "white",
             "Schwarz": "black",
@@ -32,28 +92,32 @@ def add_text_to_image(image, text, text_x, text_y, font_size="80px", font_family
         actual_color = color_mapping.get(font_color, "white")
         print(f"Schriftfarbe Mapping: {font_color} -> {actual_color}")
         
-        # NEU: 3 garantierte TrueType-Schriftarten mit relativen Pfaden
-        font_paths = {
-            "Roboto": "./fonts/Roboto-Regular.ttf",
-            "Open Sans": "./fonts/OpenSans-Regular.ttf", 
-            "DejaVu Sans": "./fonts/DejaVuSans.ttf"
-        }
+        # NEU: Schriftart downloaden oder vorhandene verwenden
+        font_path = download_font(font_family)
         
-        try:
-            font_path = font_paths.get(font_family, "./fonts/Roboto-Regular.ttf")
-            font = ImageFont.truetype(font_path, pixel_size)
-            print(f"Schriftart geladen: {font_family} mit Größe {pixel_size}px")
-            
-        except Exception as font_error:
-            print(f"Fehler beim Laden der Schriftart {font_family}: {font_error}")
-            # Fallback: Versuche die erste verfügbare Schriftart
+        if font_path:
             try:
-                font = ImageFont.truetype("./fonts/Roboto-Regular.ttf", pixel_size)
-                print(f"Fallback auf Roboto mit Größe {pixel_size}px")
-            except:
-                # Letzter Fallback - sollte nicht passieren wenn Schriftarten vorhanden sind
+                font = ImageFont.truetype(font_path, pixel_size)
+                print(f"✅ TrueType-Schriftart geladen: {font_family} mit Größe {pixel_size}px")
+            except Exception as e:
+                print(f"❌ Fehler beim Laden der Schriftart {font_family}: {e}")
+                # Fallback auf andere Schriftart
+                fallback_font = get_available_font()
+                if fallback_font:
+                    font = ImageFont.truetype(fallback_font, pixel_size)
+                    print(f"⚠️ Fallback auf: {fallback_font}")
+                else:
+                    font = ImageFont.load_default()
+                    print("⚠️ Fallback auf Default-Schriftart (nicht skalierbar)")
+        else:
+            # Fallback falls Download fehlschlägt
+            fallback_font = get_available_font()
+            if fallback_font:
+                font = ImageFont.truetype(fallback_font, pixel_size)
+                print(f"⚠️ Download fehlgeschlagen - verwende Fallback: {fallback_font}")
+            else:
                 font = ImageFont.load_default()
-                print(f"KRITISCH: Keine TrueType-Schriftart gefunden! Verwende Default (nicht skalierbar)")
+                print("⚠️ Keine TrueType-Schriftart verfügbar - verwende Default (nicht skalierbar)")
         
         # Text zeichnen
         draw.text((text_x, text_y), text, fill=actual_color, font=font)
@@ -65,22 +129,19 @@ def add_text_to_image(image, text, text_x, text_y, font_size="80px", font_family
         return image
 
 def create_text_preview(image, text, text_x, text_y, font_size="80px", font_family="Roboto", font_color="Weiß"):
-    """Erstellt eine Vorschau mit Text und rotem Marker - nur EINEN Punkt"""
+    """Erstellt eine Vorschau mit Text und rotem Marker"""
     if image is None:
         return image
         
     try:
-        # Konvertiere numpy array zu PIL Image falls nötig
         if isinstance(image, np.ndarray):
             image = Image.fromarray(image)
         
-        # Immer vom Originalbild starten, nicht von der vorherigen Vorschau
         preview = image.copy()
         draw = ImageDraw.Draw(preview)
         
-        # Nur roten Marker zeichnen wenn Text vorhanden UND Position nicht Standard (100,100)
+        # Rote Marker
         if text and text_x is not None and text_y is not None and (text_x != 100 or text_y != 100):
-            # Rote Marker an Textposition
             marker_radius = 8
             marker_color = (255, 0, 0)
             draw.ellipse([
@@ -90,15 +151,13 @@ def create_text_preview(image, text, text_x, text_y, font_size="80px", font_fami
                 text_y + marker_radius
             ], fill=marker_color)
         
-        # Text zeichnen wenn vorhanden
+        # Text zeichnen
         if text:
-            # Schriftgröße direkt aus dem Dropdown-Wert extrahieren
             try:
                 pixel_size = int(font_size.replace("px", ""))
             except:
                 pixel_size = 80
             
-            # Schriftfarbe Mapping für Vorschau
             color_mapping = {
                 "Weiß": "white",
                 "Schwarz": "black",
@@ -107,24 +166,24 @@ def create_text_preview(image, text, text_x, text_y, font_size="80px", font_fami
             
             actual_color = color_mapping.get(font_color, "white")
             
-            # NEU: Gleiche Schriftart-Logik wie in add_text_to_image
-            font_paths = {
-                "Roboto": "./fonts/Roboto-Regular.ttf",
-                "Open Sans": "./fonts/OpenSans-Regular.ttf",
-                "DejaVu Sans": "./fonts/DejaVuSans.ttf"
-            }
+            # Gleiche Schriftart-Logik wie oben
+            font_path = download_font(font_family)
             
-            try:
-                font_path = font_paths.get(font_family, "./fonts/Roboto-Regular.ttf")
-                font = ImageFont.truetype(font_path, pixel_size)
-            except Exception as font_error:
-                print(f"Fehler beim Laden der Schriftart für Vorschau: {font_error}")
-                # Fallback
+            if font_path:
                 try:
-                    font = ImageFont.truetype("./fonts/Roboto-Regular.ttf", pixel_size)
+                    font = ImageFont.truetype(font_path, pixel_size)
                 except:
+                    fallback_font = get_available_font()
+                    if fallback_font:
+                        font = ImageFont.truetype(fallback_font, pixel_size)
+                    else:
+                        font = ImageFont.load_default()
+            else:
+                fallback_font = get_available_font()
+                if fallback_font:
+                    font = ImageFont.truetype(fallback_font, pixel_size)
+                else:
                     font = ImageFont.load_default()
-                    print("WARNUNG: Fallback auf nicht-skalierbare Default-Schriftart")
             
             draw.text((text_x, text_y), text, fill=actual_color, font=font)
             print(f"Vorschau: Text mit Größe {pixel_size}px, Farbe {actual_color} gezeichnet")
@@ -135,31 +194,25 @@ def create_text_preview(image, text, text_x, text_y, font_size="80px", font_fami
         print(f"Fehler bei Text-Vorschau: {e}")
         return image
 
+# Rest der Funktionen bleibt gleich wie vorher...
 def update_text_preview_i2i(original_image, generated_image, text, text_x, text_y, target_selector):
-    """Aktualisiert die Text-Vorschau für Bild-zu-Bild"""
     if target_selector == "Originalbild":
         target_image = original_image
-    else:  # "Generiertes Bild"
+    else:
         target_image = generated_image
-    
     return create_text_preview(target_image, text, text_x, text_y)
 
 def update_text_preview_t2i(image, text, text_x, text_y, font_size, font_family, font_color):
-    """Aktualisiert die Text-Vorschau für Text-zu-Bild mit Formatierung"""
     print(f"Update Vorschau - Größe: {font_size}, Schrift: {font_family}, Farbe: {font_color}")
     return create_text_preview(image, text, text_x, text_y, font_size, font_family, font_color)
 
 def capture_click(event: gr.SelectData):
-    """Handhabt Klicks in beiden Tabs"""
     if event and hasattr(event, 'index'):
         print(f"🎯 CLICK ERFOLGREICH: ({event.index[0]}, {event.index[1]})")
         return event.index[0], event.index[1]
-    print("❌ CLICK FEHLGESCHLAGEN - Event oder Index fehlt")
     return 100, 100
 
 def create_text_integration_section_t2i():
-    """Erstellt die UI-Komponenten für Text-Integration in Text-zu-Bild"""
-    
     with gr.Row():
         gr.Markdown("### 📝 Text auf Bild integrieren")
     
@@ -171,7 +224,6 @@ def create_text_integration_section_t2i():
             scale=3
         )
         
-    # TEXT-FORMATIERUNGSOPTIONEN
     with gr.Row():
         with gr.Column():
             font_size_t2i = gr.Dropdown(
@@ -181,7 +233,7 @@ def create_text_integration_section_t2i():
             )
         with gr.Column():
             font_family_t2i = gr.Dropdown(
-                choices=["Roboto", "Open Sans", "DejaVu Sans"],  # NEU: 3 TrueType-Schriftarten
+                choices=["Roboto", "Open Sans", "DejaVu Sans"],
                 value="Roboto", 
                 label="Schriftart"
             )
@@ -193,7 +245,6 @@ def create_text_integration_section_t2i():
             )
         
     with gr.Row():
-        # Start mit None statt 100, damit kein Marker an Standard-Position
         text_x_t2i = gr.Number(value=None, visible=False)
         text_y_t2i = gr.Number(value=None, visible=False)
         
@@ -203,8 +254,6 @@ def create_text_integration_section_t2i():
     return text_input_t2i, text_x_t2i, text_y_t2i, font_size_t2i, font_family_t2i, font_color_t2i, text_btn_t2i
 
 def create_text_integration_section_i2i():
-    """Erstellt die UI-Komponenten für Text-Integration in Bild-zu-Bild"""
-    
     with gr.Row():
         gr.Markdown("### 📝 Text auf Bild integrieren")
     
@@ -217,7 +266,6 @@ def create_text_integration_section_i2i():
         )
         
     with gr.Row():
-        # Start mit None statt 100, damit kein Marker an Standard-Position
         text_x_i2i = gr.Number(value=None, visible=False)
         text_y_i2i = gr.Number(value=None, visible=False)