Update text_integration.py

text_integration.py

@@ -1,202 +1,132 @@
 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://raw.githubusercontent.com/google/fonts/main/apache/roboto/Roboto-Regular.ttf",
-    "Open Sans": "https://raw.githubusercontent.com/google/fonts/main/apache/opensans/OpenSans-Regular.ttf",
-    "DejaVu Sans": "https://raw.githubusercontent.com/dejavu-fonts/dejavu-fonts/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
+import cv2
 
 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"""
+    """Fügt Text mit OpenCV zum Bild hinzu - garantiert skalierbar!"""
     if image is None or not text:
         return image
         
     try:
-        # Konvertiere numpy array zu PIL Image falls nötig
+        # Konvertiere PIL Image zu OpenCV Format
         if isinstance(image, np.ndarray):
-            image = Image.fromarray(image)
-        
-        image_with_text = image.copy()
-        draw = ImageDraw.Draw(image_with_text)
+            opencv_image = image
+        else:
+            opencv_image = np.array(image)
+            opencv_image = cv2.cvtColor(opencv_image, cv2.COLOR_RGB2BGR)
         
-        # Schriftgröße direkt aus dem Dropdown-Wert extrahieren
+        # Schriftgröße
         try:
             pixel_size = int(font_size.replace("px", ""))
-            print(f"Schriftgröße direkt: {font_size} -> {pixel_size}px")
+            # OpenCV Font-Skala anpassen (empirische Werte)
+            font_scale = pixel_size / 30.0
         except:
-            pixel_size = 80
+            font_scale = 2.0
         
-        # Schriftfarbe Mapping
+        # Schriftfarbe
         color_mapping = {
-            "Weiß": "white",
-            "Schwarz": "black",
-            "Rot": "red"
+            "Weiß": (255, 255, 255),
+            "Schwarz": (0, 0, 0),
+            "Rot": (0, 0, 255)
         }
+        actual_color = color_mapping.get(font_color, (255, 255, 255))
+        
+        # OpenCV Font - GARANTIERT verfügbar und skalierbar!
+        font = cv2.FONT_HERSHEY_SIMPLEX
+        thickness = max(2, int(pixel_size / 20))
+        
+        print(f"OpenCV Text: '{text}' an ({text_x}, {text_y}) - Größe: {font_scale:.2f}, Dicke: {thickness}")
+        
+        # Text mit OpenCV hinzufügen
+        cv2.putText(
+            opencv_image, 
+            text, 
+            (int(text_x), int(text_y)), 
+            font, 
+            font_scale, 
+            actual_color, 
+            thickness, 
+            cv2.LINE_AA
+        )
         
-        actual_color = color_mapping.get(font_color, "white")
-        print(f"Schriftfarbe Mapping: {font_color} -> {actual_color}")
-        
-        # NEU: Schriftart downloaden oder vorhandene verwenden
-        font_path = download_font(font_family)
-        
-        if font_path:
-            try:
-                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("⚠️ Keine TrueType-Schriftart verfügbar - verwende Default (nicht skalierbar)")
-        
-        # Text zeichnen
-        draw.text((text_x, text_y), text, fill=actual_color, font=font)
-        print(f"Text '{text}' an Position ({text_x}, {text_y}) hinzugefügt - Größe: {pixel_size}px, Schrift: {font_family}, Farbe: {actual_color}")
-        return image_with_text
+        # Zurück zu PIL Format
+        result_image = cv2.cvtColor(opencv_image, cv2.COLOR_BGR2RGB)
+        return Image.fromarray(result_image)
         
     except Exception as e:
-        print(f"Fehler beim Text hinzufügen: {e}")
-        return image
+        print(f"Fehler beim Text hinzufügen mit OpenCV: {e}")
+        # Fallback zu PIL
+        try:
+            if isinstance(image, np.ndarray):
+                image = Image.fromarray(image)
+            image_with_text = image.copy()
+            draw = ImageDraw.Draw(image_with_text)
+            draw.text((text_x, text_y), text, fill="white")
+            return image_with_text
+        except:
+            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"""
+    """Vorschau mit OpenCV"""
     if image is None:
         return image
         
     try:
+        # Zu OpenCV konvertieren
         if isinstance(image, np.ndarray):
-            image = Image.fromarray(image)
+            opencv_image = image
+        else:
+            opencv_image = np.array(image)
+            opencv_image = cv2.cvtColor(opencv_image, cv2.COLOR_RGB2BGR)
         
-        preview = image.copy()
-        draw = ImageDraw.Draw(preview)
+        preview = opencv_image.copy()
         
         # Rote Marker
         if text and text_x is not None and text_y is not None and (text_x != 100 or text_y != 100):
-            marker_radius = 8
-            marker_color = (255, 0, 0)
-            draw.ellipse([
-                text_x - marker_radius, 
-                text_y - marker_radius,
-                text_x + marker_radius, 
-                text_y + marker_radius
-            ], fill=marker_color)
+            cv2.circle(preview, (int(text_x), int(text_y)), 8, (0, 0, 255), -1)
         
         # Text zeichnen
         if text:
             try:
                 pixel_size = int(font_size.replace("px", ""))
+                font_scale = pixel_size / 30.0
             except:
-                pixel_size = 80
+                font_scale = 2.0
             
             color_mapping = {
-                "Weiß": "white",
-                "Schwarz": "black",
-                "Rot": "red"
+                "Weiß": (255, 255, 255),
+                "Schwarz": (0, 0, 0),
+                "Rot": (0, 0, 255)
             }
+            actual_color = color_mapping.get(font_color, (255, 255, 255))
             
-            actual_color = color_mapping.get(font_color, "white")
+            font = cv2.FONT_HERSHEY_SIMPLEX
+            thickness = max(2, int(pixel_size / 20))
             
-            # Gleiche Schriftart-Logik wie oben
-            font_path = download_font(font_family)
-            
-            if font_path:
-                try:
-                    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()
+            cv2.putText(
+                preview, 
+                text, 
+                (int(text_x), int(text_y)), 
+                font, 
+                font_scale, 
+                actual_color, 
+                thickness, 
+                cv2.LINE_AA
+            )
             
-            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")
+            print(f"OpenCV Vorschau: Größe {font_scale:.2f}")
         
-        return preview
+        # Zurück zu PIL
+        result_image = cv2.cvtColor(preview, cv2.COLOR_BGR2RGB)
+        return Image.fromarray(result_image)
         
     except Exception as e:
-        print(f"Fehler bei Text-Vorschau: {e}")
+        print(f"Fehler bei OpenCV 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:
@@ -204,16 +134,20 @@ def update_text_preview_i2i(original_image, generated_image, text, text_x, text_
     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]
     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")
     
@@ -234,8 +168,8 @@ def create_text_integration_section_t2i():
             )
         with gr.Column():
             font_family_t2i = gr.Dropdown(
-                choices=["Roboto", "Open Sans", "DejaVu Sans"],
-                value="Roboto", 
+                choices=["Standard"],
+                value="Standard", 
                 label="Schriftart"
             )
         with gr.Column():
@@ -255,6 +189,8 @@ 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")