Update app.py

app.py

@@ -2,18 +2,29 @@ import gradio as gr
 import matplotlib.pyplot as plt
 from io import BytesIO
 from PIL import Image, ImageDraw, ImageFont
-
-# Function to convert text to an image
-def render_text_image(text, font_size, width, height, bg_color, text_color):
-    """Converts plain text to an image."""
-    
-    # Convert RGBA float colors to RGB tuples
-    def parse_color(color):
-        if isinstance(color, str) and "rgba" in color:
-            color = color.replace("rgba", "").strip("()").split(",")
-            return tuple(int(float(c)) for c in color[:3])  # Convert to (R, G, B)
-        return color
-
+import textwrap
+import os
+import matplotlib
+
+# Function to get available system fonts
+def get_system_fonts():
+    fonts = []
+    for font in matplotlib.font_manager.findSystemFonts(fontpaths=None, fontext='ttf'):
+        font_name = os.path.basename(font)
+        fonts.append(font_name)
+    return sorted(set(fonts))
+
+# Function to parse color
+def parse_color(color):
+    """Convert RGBA string to RGB tuple if necessary."""
+    if isinstance(color, str) and color.startswith('rgba'):
+        color = color.replace('rgba', '').strip('()').split(',')
+        return tuple(int(float(c.strip())) for c in color[:3])  # Convert to (R, G, B)
+    return color  # If already valid, return as is
+
+# Function to render plain text as an image
+def render_plain_text_image(text, font_size, width, height, bg_color, text_color, font_name, align):
+    """Convert plain text to an image with the given parameters."""
     bg_color = parse_color(bg_color)
     text_color = parse_color(text_color)
 
@@ -21,85 +32,138 @@ def render_text_image(text, font_size, width, height, bg_color, text_color):
     img = Image.new("RGB", (width, height), color=bg_color)
     draw = ImageDraw.Draw(img)
 
-    # Load a default font
+    # Load font
     try:
-        font = ImageFont.truetype("arial.ttf", font_size)
-    except IOError:
+        font_path = matplotlib.font_manager.findfont(font_name)
+        font = ImageFont.truetype(font_path, font_size)
+    except Exception:
         font = ImageFont.load_default()
 
-    # Get text size
-    text_width, text_height = draw.textsize(text, font=font)
-
-    # Center text
-    text_x = (width - text_width) // 2
-    text_y = (height - text_height) // 2
-
-    # Draw text on image
-    draw.text((text_x, text_y), text, font=font, fill=text_color)
+    # Text wrapping
+    margin = 10
+    max_width = width - 2 * margin
+    lines = []
+    for line in text.split('\n'):
+        lines.extend(textwrap.wrap(line, width=int(max_width / font_size * 1.8)))
+
+    # Calculate total text height
+    line_height = font.getsize('Ay')[1]
+    total_text_height = line_height * len(lines)
+
+    # Starting position
+    y = (height - total_text_height) // 2
+
+    for line in lines:
+        line_width = font.getsize(line)[0]
+        if align == 'Left':
+            x = margin
+        elif align == 'Center':
+            x = (width - line_width) // 2
+        else:  # Right alignment
+            x = width - line_width - margin
+        draw.text((x, y), line, fill=text_color, font=font)
+        y += line_height
 
     return img
 
-# Function to render LaTeX equations as an image
+# Function to render math (LaTeX) as an image
 def render_math_image(text, font_size, width, height, bg_color, text_color):
-    """Converts LaTeX math expressions into an image."""
-    fig, ax = plt.subplots(figsize=(width / 100, height / 100))
-    ax.set_axis_off()
+    """Convert LaTeX-formatted text to an image."""
+    bg_color = parse_color(bg_color)
+    text_color = parse_color(text_color)
 
-    # Ensure proper LaTeX formatting
-    try:
-        formatted_text = rf"${text}$"
-    except Exception as e:
-        return f"Error parsing LaTeX: {e}"
+    fig, ax = plt.subplots(figsize=(width / 100, height / 100), facecolor=bg_color)
+    ax.set_facecolor(bg_color)
+    ax.axis('off')
+
+    # Ensure LaTeX formatting is correct
+    if not (text.startswith(r"$") and text.endswith(r"$")):
+        text = rf"${text}$"
 
-    ax.text(0.5, 0.5, formatted_text, fontsize=font_size, ha='center', va='center', color=text_color)
+    ax.text(0.5, 0.5, text, fontsize=font_size, ha='center', va='center', color=text_color)
 
     buf = BytesIO()
-    plt.savefig(buf, format="png", bbox_inches="tight", pad_inches=0.1)
+    plt.savefig(buf, format='png', bbox_inches='tight', pad_inches=0)
     plt.close(fig)
 
     buf.seek(0)
     return Image.open(buf)
 
-# File handler function
-def process_text_or_file(input_text, uploaded_file, font_size, width, height, bg_color, text_color):
-    """Handles text input or file upload to generate an image."""
-    
-    # Read text from uploaded file
-    if uploaded_file is not None:
-        text = uploaded_file.read().decode("utf-8")
+# Main function to handle input
+def text_to_image(input_text, font_size, width, height, bg_color, text_color, mode, font_name, align, image_format):
+    """Determine whether to use plain text or LaTeX rendering."""
+    if mode == "Plain Text":
+        img = render_plain_text_image(input_text, font_size, width, height, bg_color, text_color, font_name, align)
+    elif mode == "LaTeX Math":
+        img = render_math_image(input_text, font_size, width, height, bg_color, text_color)
     else:
-        text = input_text
+        return "Invalid mode selected!"
 
-    # Determine if the text is a LaTeX equation
-    if "$" in text or "\\" in text:
-        return render_math_image(text, font_size, width, height, bg_color, text_color)
-    else:
-        return render_text_image(text, font_size, width, height, bg_color, text_color)
+    # Save image to buffer
+    buf = BytesIO()
+    img.save(buf, format=image_format)
+    buf.seek(0)
+    return buf
 
-# Gradio UI
+# Function to handle file upload
+def handle_file_upload(file, font_size, width, height, bg_color, text_color, mode, font_name, align, image_format):
+    """Extract text from file and convert to an image."""
+    if file is not None:
+        text = file.read().decode("utf-8")  # Read and decode text file
+        return text_to_image(text, font_size, width, height, bg_color, text_color, mode, font_name, align, image_format)
+    return "No file uploaded!"
+
+# Get list of system fonts
+font_list = get_system_fonts()
+default_font = "DejaVuSans.ttf" if "DejaVuSans.ttf" in font_list else font_list[0]
+
+# Gradio Interface
 with gr.Blocks() as demo:
-    gr.Markdown("## 🖼️ Convert Text or Math to Image")
+    gr.Markdown("# 🖼️ Text to Image Converter")
 
     with gr.Row():
-        input_text = gr.Textbox(label="Enter Text or LaTeX", lines=3)
-        uploaded_file = gr.File(label="Upload a File (TXT, CSV)")
+        input_text = gr.Textbox(label="Enter Text", placeholder="Type or paste text here...")
+        file_input = gr.File(label="Upload a Text File", type="file")
 
     with gr.Row():
-        font_size = gr.Slider(10, 100, value=30, step=2, label="Font Size")
-        width = gr.Slider(100, 1000, value=500, step=50, label="Image Width")
-        height = gr.Slider(100, 1000, value=200, step=50, label="Image Height")
+        font_size = gr.Slider(10, 100, value=30, label="Font Size")
+        font_name = gr.Dropdown(choices=font_list, value=default_font, label="Font")
+        align = gr.Radio(["Left", "Center", "Right"], label="Text Alignment", value="Center")
+
+    with gr.Row():
+        width = gr.Slider(200, 2000, value=800, label="Image Width")
+        height = gr.Slider(200, 2000, value=600, label="Image Height")
 
     with gr.Row():
         bg_color = gr.ColorPicker(label="Background Color", value="#FFFFFF")
         text_color = gr.ColorPicker(label="Text Color", value="#000000")
 
-    output_image = gr.Image(type="pil", label="Generated Image")
+    with gr.Row():
+        mode = gr.Radio(["Plain Text", "LaTeX Math"], label="Rendering Mode", value="Plain Text")
+        image_format = gr.Radio(["PNG", "JPEG"], label="Image Format", value="PNG")
+
+    output_image = gr.Image(label="Generated Image")
+
+    with gr.Row():
+        convert_button = gr.Button("Convert Text to Image")
+        file_convert_button = gr.Button("Convert File to Image")
+
+    convert_button.click(
+        text_to_image,
+        inputs=[
+            input_text, font_size, width, height, bg_color, text_color,
+            mode, font_name, align, image_format
+        ],
+        outputs=output_image
+    )
 
-    gr.Button("Generate Image").click(
-        fn=process_text_or_file, 
-        inputs=[input_text, uploaded_file, font_size, width, height, bg_color, text_color],
+    file_convert_button.click(
+        handle_file_upload,
+        inputs=[
+            file_input, font_size, width, height, bg_color, text_color,
+            mode, font_name, align, image_format
+        ],
         outputs=output_image
     )
 
-# Run Gradio app
 demo.launch()