Update app.py

app.py

@@ -1,512 +1,191 @@
 import gradio as gr
 import matplotlib.pyplot as plt
 from io import BytesIO
-from PIL import Image, ImageDraw, ImageFont, ImageFilter
+from PIL import Image, ImageDraw, ImageFont
 import textwrap
 import os
 import matplotlib
 import math
 import zipfile
-import tempfile
-import shutil
-import numpy as np
-from typing import Dict, List, Tuple, Optional
-import re
 
-# Constants
-FONTS_DIR = os.path.join(tempfile.gettempdir(), 'text_to_image_fonts')
-SUPPORTED_FONT_TYPES = ('.ttf', '.otf', '.shx')
-DEFAULT_MARGIN = 10
+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))
 
-class FontManager:
-    def __init__(self):
-        self.fonts_dir = FONTS_DIR
-        os.makedirs(self.fonts_dir, exist_ok=True)
-        self.font_cache: Dict[str, Dict] = {}
-        self.reload_fonts()
-
-    def reload_fonts(self):
-        """Reload all available fonts"""
-        self.font_cache.clear()
-        # System fonts
-        for font in matplotlib.font_manager.findSystemFonts(fontpaths=None, fontext='ttf'):
-            font_name = os.path.basename(font)
-            self.font_cache[font_name] = {
-                "name": font_name,
-                "path": font,
-                "type": "system"
-            }
-        
-        # Custom fonts
-        if os.path.exists(self.fonts_dir):
-            for font in os.listdir(self.fonts_dir):
-                if font.lower().endswith(SUPPORTED_FONT_TYPES):
-                    font_path = os.path.join(self.fonts_dir, font)
-                    self.font_cache[font] = {
-                        "name": font,
-                        "path": font_path,
-                        "type": f"custom_{os.path.splitext(font)[1][1:]}"
-                    }
-
-    def get_font_list(self) -> List[Dict]:
-        """Get sorted list of all available fonts"""
-        return sorted(self.font_cache.values(), key=lambda x: (x["type"], x["name"]))
+def extract_and_load_fonts(zip_path, extract_to="extracted_fonts"):
+    if not os.path.exists(extract_to):
+        os.makedirs(extract_to)
+    
+    with zipfile.ZipFile(zip_path, 'r') as zip_ref:
+        zip_ref.extractall(extract_to)
+    
+    fonts = []
+    for root, dirs, files in os.walk(extract_to):
+        for file in files:
+            if file.endswith(".ttf") or file.endswith(".shx"):
+                fonts.append(os.path.join(root, file))
+    return fonts
+
+def parse_color(color):
+    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])
+    return color
+
+def calculate_text_dimensions(text, font, max_width, margin):
+    lines = []
+    for line in text.split('\n'):
+        lines.extend(textwrap.wrap(line, width=int(max_width / font.size * 1.8)))
+    
+    bbox = font.getbbox('Ay')
+    line_height = bbox[3] - bbox[1]
+    total_height = line_height * len(lines)
+    
+    return lines, line_height, total_height
 
-    def extract_fonts_from_zip(self, zip_path: str) -> List[str]:
-        """Extract fonts from ZIP file"""
-        extracted_files = []
-        with zipfile.ZipFile(zip_path, 'r') as zip_ref:
-            for file in zip_ref.namelist():
-                if file.lower().endswith(SUPPORTED_FONT_TYPES):
-                    zip_ref.extract(file, self.fonts_dir)
-                    extracted_files.append(os.path.join(self.fonts_dir, file))
-        self.reload_fonts()
-        return extracted_files
+def create_text_segment(lines, start_idx, max_lines, width, height, bg_color, text_color, font, align, margin):
+    img = Image.new("RGB", (width, height), color=bg_color)
+    draw = ImageDraw.Draw(img)
+    
+    bbox = font.getbbox('Ay')
+    line_height = bbox[3] - bbox[1]
+    
+    y = margin
+    end_idx = min(start_idx + max_lines, len(lines))
+    segment_lines = lines[start_idx:end_idx]
+    
+    for line in segment_lines:
+        bbox = font.getbbox(line)
+        line_width = bbox[2] - bbox[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, end_idx
 
-    def get_font(self, font_name: str, size: int) -> ImageFont.FreeTypeFont:
-        """Get font instance by name and size"""
-        font_info = self.font_cache.get(font_name)
-        if not font_info:
-            return ImageFont.load_default()
-        
-        try:
-            if font_info["type"] == "custom_shx":
-                # Implement SHX font loading here
-                # For now, return default font
-                return ImageFont.load_default()
-            else:
-                return ImageFont.truetype(font_info["path"], size)
-        except Exception as e:
-            print(f"Error loading font {font_name}: {e}")
-            return ImageFont.load_default()
+def render_plain_text_image(text, font_size, width, height, bg_color, text_color, font_path, align):
+    bg_color = parse_color(bg_color)
+    text_color = parse_color(text_color)
+    margin = 10
 
-class TextEffects:
-    @staticmethod
-    def apply_shadow(draw: ImageDraw.ImageDraw, text: str, x: int, y: int, 
-                    font: ImageFont.FreeTypeFont, shadow_color: Tuple[int, int, int, int],
-                    offset: int = 2):
-        """Apply shadow effect to text"""
-        draw.text((x + offset, y + offset), text, fill=shadow_color, font=font)
+    try:
+        font = ImageFont.truetype(font_path, font_size)
+    except Exception:
+        font = ImageFont.load_default()
 
-    @staticmethod
-    def apply_outline(draw: ImageDraw.ImageDraw, text: str, x: int, y: int,
-                     font: ImageFont.FreeTypeFont, outline_color: Tuple[int, int, int, int],
-                     width: int = 1):
-        """Apply outline effect to text"""
-        for off_x, off_y in [(i, j) for i in range(-width, width+1) 
-                            for j in range(-width, width+1) 
-                            if (i, j) != (0, 0)]:
-            draw.text((x + off_x, y + off_y), text, fill=outline_color, font=font)
+    # Calculate dimensions
+    max_width = width - 2 * margin
+    lines, line_height, total_text_height = calculate_text_dimensions(text, font, max_width, margin)
+    
+    # Calculate how many lines can fit in one segment
+    max_lines_per_segment = (height - 2 * margin) // line_height
+    
+    # Calculate number of segments needed
+    num_segments = math.ceil(len(lines) / max_lines_per_segment)
+    
+    # Create segments
+    segments = []
+    current_line = 0
+    
+    for i in range(num_segments):
+        segment_img, current_line = create_text_segment(
+            lines, current_line, max_lines_per_segment,
+            width, height, bg_color, text_color, font, align, margin
+        )
+        segments.append(segment_img)
+    
+    # Combine all segments vertically
+    total_height = len(segments) * height
+    final_image = Image.new("RGB", (width, total_height), color=bg_color)
+    
+    for i, segment in enumerate(segments):
+        final_image.paste(segment, (0, i * height))
+    
+    return final_image
 
-    @staticmethod
-    def apply_gradient(img: Image.Image, start_color: Tuple[int, int, int],
-                      end_color: Tuple[int, int, int], direction: str = 'vertical'):
-        """Apply gradient effect to image"""
-        width, height = img.size
-        gradient = Image.new('RGBA', img.size, (0, 0, 0, 0))
-        draw = ImageDraw.Draw(gradient)
-        
-        for i in range(height if direction == 'vertical' else width):
-            progress = i / (height if direction == 'vertical' else width)
-            color = tuple(int(start + (end - start) * progress)
-                         for start, end in zip(start_color, end_color))
-            if direction == 'vertical':
-                draw.line([(0, i), (width, i)], fill=color)
-            else:
-                draw.line([(i, 0), (i, height)], fill=color)
-        
-        return Image.alpha_composite(img, gradient)
+def render_math_image(text, font_size, width, height, bg_color, text_color):
+    bg_color = parse_color(bg_color)
+    text_color = parse_color(text_color)
 
-class TextRenderer:
-    def __init__(self):
-        self.font_manager = FontManager()
+    fig, ax = plt.subplots(figsize=(width / 100, height / 100), facecolor=bg_color)
+    ax.set_facecolor(bg_color)
+    ax.axis('off')
 
-    def parse_color(self, color: str) -> Tuple[int, int, int]:
-        """Parse color string to RGB tuple"""
-        if isinstance(color, str):
-            if color.startswith('rgba'):
-                color = color.replace('rgba', '').strip('()').split(',')
-                return tuple(int(float(c.strip())) for c in color[:3])
-            elif color.startswith('#'):
-                color = color.lstrip('#')
-                return tuple(int(color[i:i+2], 16) for i in (0, 2, 4))
-        return color
+    if not (text.startswith(r"$") and text.endswith(r"$")):
+        text = rf"${text}$"
 
-    def calculate_text_dimensions(self, text: str, font: ImageFont.FreeTypeFont,
-                                max_width: int) -> Tuple[List[str], int, int]:
-        """Calculate text dimensions and wrap lines"""
-        lines = []
-        for line in text.split('\n'):
-            wrapped = textwrap.wrap(line, width=int(max_width / font.size * 1.8))
-            lines.extend(wrapped if wrapped else [''])  # Preserve empty lines
-        
-        bbox = font.getbbox('Ay')
-        line_height = bbox[3] - bbox[1]
-        total_height = line_height * len(lines)
-        
-        return lines, line_height, total_height
+    ax.text(0.5, 0.5, text, fontsize=font_size, ha='center', va='center', color=text_color)
 
-    def create_text_segment(self, lines: List[str], start_idx: int, max_lines: int,
-                          width: int, height: int, bg_color: Tuple[int, int, int, int],
-                          text_color: Tuple[int, int, int, int], font_info: Dict,
-                          font_size: int, align: str, margin: int,
-                          effects: List[str]) -> Tuple[Image.Image, int]:
-        """Create a segment of text with applied effects"""
-        img = Image.new("RGBA", (width, height), color=bg_color)
-        draw = ImageDraw.Draw(img)
-        
-        font = self.font_manager.get_font(font_info["name"], font_size)
-        bbox = font.getbbox('Ay')
-        line_height = bbox[3] - bbox[1]
-        
-        y = margin
-        end_idx = min(start_idx + max_lines, len(lines))
-        segment_lines = lines[start_idx:end_idx]
-        
-        for line in segment_lines:
-            bbox = font.getbbox(line)
-            line_width = bbox[2] - bbox[0]
-            
-            if align == 'Left':
-                x = margin
-            elif align == 'Center':
-                x = (width - line_width) // 2
-            else:  # Right alignment
-                x = width - line_width - margin
-            
-            # Apply effects
-            if 'shadow' in effects:
-                TextEffects.apply_shadow(draw, line, x, y, font,
-                                      (0, 0, 0, 128))
-            
-            if 'outline' in effects:
-                TextEffects.apply_outline(draw, line, x, y, font,
-                                       (0, 0, 0, 255))
-            
-            if 'gradient' in effects:
-                # Save current position for gradient application
-                gradient_pos = (x, y, x + line_width, y + line_height)
-            
-            draw.text((x, y), line, fill=text_color, font=font)
-            
-            if 'gradient' in effects:
-                # Apply gradient to the text area
-                gradient_overlay = Image.new('RGBA', (line_width, line_height))
-                TextEffects.apply_gradient(gradient_overlay,
-                                        (255, 0, 0), (0, 0, 255))
-                img.paste(gradient_overlay, gradient_pos, gradient_overlay)
-            
-            y += line_height
-        
-        if 'blur' in effects:
-            img = img.filter(ImageFilter.GaussianBlur(radius=1))
-        
-        return img, end_idx
+    buf = BytesIO()
+    plt.savefig(buf, format='png', bbox_inches='tight', pad_inches=0)
+    plt.close(fig)
 
-    def render_text_image(self, text: str, font_size: int, width: int, height: int,
-                         bg_color: Tuple[int, int, int, int],
-                         text_color: Tuple[int, int, int, int],
-                         font_name: str, align: str, effects: List[str],
-                         margin: int = DEFAULT_MARGIN) -> Image.Image:
-        """Render text to image with all effects"""
-        font_info = next((f for f in self.font_manager.get_font_list()
-                         if f["name"] == font_name), None)
-        if not font_info:
-            font_info = {"name": "default", "path": None, "type": "system"}
-        
-        font = self.font_manager.get_font(font_info["name"], font_size)
-        max_width = width - 2 * margin
-        lines, line_height, total_height = self.calculate_text_dimensions(
-            text, font, max_width)
-        
-        max_lines_per_segment = (height - 2 * margin) // line_height
-        num_segments = math.ceil(len(lines) / max_lines_per_segment)
-        
-        segments = []
-        current_line = 0
-        
-        for i in range(num_segments):
-            segment_img, current_line = self.create_text_segment(
-                lines, current_line, max_lines_per_segment,
-                width, height, bg_color, text_color, font_info,
-                font_size, align, margin, effects
-            )
-            segments.append(segment_img)
-        
-        total_height = len(segments) * height
-        final_image = Image.new("RGBA", (width, total_height), color=bg_color)
-        
-        for i, segment in enumerate(segments):
-            final_image.paste(segment, (0, i * height), segment)
-        
-        return final_image
+    buf.seek(0)
+    img = Image.open(buf)
+    return img
 
-    def render_math_image(self, text: str, font_size: int, width: int, height: int,
-                         bg_color: Tuple[int, int, int, int],
-                         text_color: Tuple[int, int, int, int]) -> Image.Image:
-        """Render mathematical equations"""
-        fig, ax = plt.subplots(figsize=(width/100, height/100))
-        ax.set_facecolor(bg_color)
-        fig.patch.set_facecolor(bg_color)
-        ax.axis('off')
-        
-        if not (text.startswith('$') and text.endswith('$')):
-            text = f'${text}$'
-        
-        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,
-                   transparent=True)
-        plt.close(fig)
-        
-        buf.seek(0)
-        return Image.open(buf)
+def text_to_image(input_text, font_size, width, height, bg_color, text_color, mode, font_path, align, image_format):
+    if mode == "Plain Text":
+        img = render_plain_text_image(input_text, font_size, width, height, bg_color, text_color, font_path, align)
+    elif mode == "LaTeX Math":
+        img = render_math_image(input_text, font_size, width, height, bg_color, text_color)
+    else:
+        return "Invalid mode selected!"
+    
+    return img
 
-class TextToImageApp:
-    def __init__(self):
-        self.renderer = TextRenderer()
-        self.setup_interface()
+# Extract fonts from Fontsshx.zip
+extracted_fonts = extract_and_load_fonts("Fontsshx.zip")
+system_fonts = get_system_fonts()
+all_fonts = extracted_fonts + system_fonts
 
-    def handle_font_upload(self, file):
-        """Handle font file upload"""
-        if file is not None:
-            self.renderer.font_manager.extract_fonts_from_zip(file.name)
-            return gr.Dropdown.update(
-                choices=[f["name"] for f in self.renderer.font_manager.get_font_list()]
-            )
-        return gr.Dropdown.update()
+with gr.Blocks() as demo:
+    gr.Markdown("# 🖼️ Text to Image Converter")
 
-    def convert_text(self, input_text: str, font_size: int, width: int, height: int,
-                    bg_color: str, text_color: str, mode: str, font_name: str,
-                    align: str, image_format: str, effects: List[str],
-                    opacity: float) -> Image.Image:
-        """Convert text to image with all options"""
-        bg_color = (*self.renderer.parse_color(bg_color), int(opacity * 255))
-        text_color = (*self.renderer.parse_color(text_color), 255)
-        
-        if mode == "Plain Text":
-            img = self.renderer.render_text_image(
-                input_text, font_size, width, height,
-                bg_color, text_color, font_name, align, effects
-            )
-        else:  # LaTeX Math
-            img = self.renderer.render_math_image(
-                input_text, font_size, width, height,
-                bg_color, text_color
-            )
-        
-        # Convert to selected format
-        if image_format == "JPEG":
-            # Convert to RGB for JPEG
-            bg = Image.new('RGB', img.size, (255, 255, 255))
-            bg.paste(img, mask=img.split()[3])
-            img = bg
-        
-        return img
+    with gr.Row():
+        input_text = gr.Textbox(label="Enter Text", placeholder="Type or paste text here...", lines=5)
+        file_input = gr.File(label="Upload a Text File", type="filepath")
 
-    def setup_interface(self):
-        """Setup Gradio interface"""
-        with gr.Blocks() as self.demo:
-            gr.Markdown("# 🖼️ Advanced Text to Image Converter")
-            
-            with gr.Row():
-                font_upload = gr.File(
-                    label="Upload Fonts ZIP",
-                    type="file",
-                    file_types=[".zip"]
-                )
-            
-            with gr.Row():
-                input_text = gr.Textbox(
-                    label="Enter Text",
-                    placeholder="Type or paste text here...",
-                    lines=5
-                )
-            
-            with gr.Row():
-                font_size = gr.Slider(10, 100, value=30, label="Font Size")
-                font_name = gr.Dropdown(
-                    choices=[f["name"] for f in self.renderer.font_manager.get_font_list()],
-                    label="Font"
-                )
-                align = gr.Radio(
-                    ["Left", "Center", "Right"],
-                    label="Text Alignment",
-                    value="Center"
-                )
-            
-            with gr.Row():
-                effects = gr.CheckboxGroup(
-                    ["shadow", "outline", "gradient", "blur"],
-                    label="Text Effects"
-                )
-                opacity = gr.Slider(0, 1, value=1, label="Background Opacity")
-			with gr.Row():
-                width = gr.Slider(200, 2000, value=800, label="Image Width")
-                height = gr.Slider(200, 2000, value=600, label="Base Height")
-            
-            with gr.Row():
-                bg_color = gr.ColorPicker(label="Background Color", value="#FFFFFF")
-                text_color = gr.ColorPicker(label="Text Color", value="#000000")
-            
-            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")
-            
-            # Connect components
-            font_upload.upload(
-                self.handle_font_upload,
-                inputs=[font_upload],
-                outputs=[font_name]
-            )
-            
-            convert_button = gr.Button("Convert Text to Image")
-            convert_button.click(
-                self.convert_text,
-                inputs=[
-                    input_text, font_size, width, height,
-                    bg_color, text_color, mode, font_name,
-                    align, image_format, effects, opacity
-                ],
-                outputs=output_image
-            )
+    with gr.Row():
+        font_size = gr.Slider(10, 100, value=30, label="Font Size")
+        font_name = gr.Dropdown(choices=all_fonts, value=all_fonts[0], label="Font")
+        align = gr.Radio(["Left", "Center", "Right"], label="Text Alignment", value="Center")
 
-    def launch(self):
-        """Launch the Gradio interface"""
-        self.demo.launch()
+    with gr.Row():
+        width = gr.Slider(200, 2000, value=800, label="Image Width")
+        height = gr.Slider(200, 2000, value=600, label="Base Height")
 
+    with gr.Row():
+        bg_color = gr.ColorPicker(label="Background Color", value="#FFFFFF")
+        text_color = gr.ColorPicker(label="Text Color", value="#000000")
 
-class SHXFontRenderer:
-    """SHX Font Renderer for AutoCAD SHX fonts"""
-    
-    def __init__(self, shx_file_path: str):
-        self.shx_file_path = shx_file_path
-        self.font_data = self.load_shx_file()
-        
-    def load_shx_file(self) -> Dict:
-        """Load and parse SHX font file"""
-        font_data = {}
-        try:
-            with open(self.shx_file_path, 'rb') as f:
-                # Read SHX header
-                header = f.read(6)
-                if header[0:2] != b'\x1a\x00':
-                    raise ValueError("Invalid SHX file format")
-                
-                # Parse font records
-                while True:
-                    record = self.read_record(f)
-                    if not record:
-                        break
-                    if 'char_code' in record:
-                        font_data[record['char_code']] = record['vectors']
-                        
-        except Exception as e:
-            print(f"Error loading SHX font: {e}")
-            
-        return font_data
-    
-    def read_record(self, file) -> Optional[Dict]:
-        """Read a single record from SHX file"""
-        try:
-            record_type = int.from_bytes(file.read(1), byteorder='little')
-            if record_type == 0:  # EOF
-                return None
-                
-            if record_type == 0x0A:  # Character definition
-                char_code = int.from_bytes(file.read(2), byteorder='little')
-                vectors = self.read_vectors(file)
-                return {'char_code': char_code, 'vectors': vectors}
-                
-            return {}
-            
-        except Exception:
-            return None
-    
-    def read_vectors(self, file) -> List[Dict]:
-        """Read vector data for a character"""
-        vectors = []
-        while True:
-            try:
-                vector_type = int.from_bytes(file.read(1), byteorder='little')
-                if vector_type == 0:  # End of character
-                    break
-                    
-                x = int.from_bytes(file.read(1), byteorder='little', signed=True)
-                y = int.from_bytes(file.read(1), byteorder='little', signed=True)
-                
-                vectors.append({
-                    'type': vector_type,
-                    'x': x,
-                    'y': y
-                })
-                
-            except Exception:
-                break
-                
-        return vectors
-    
-    def render_text(self, text: str, size: int, color: Tuple[int, int, int, int]) -> Image.Image:
-        """Render text using SHX font"""
-        # Calculate image size based on text and font size
-        scale = size / 16.0  # Standard SHX size is 16 units
-        img_width = int(len(text) * size * 0.75)  # Approximate width
-        img_height = int(size * 1.5)
-        
-        # Create image
-        img = Image.new('RGBA', (img_width, img_height), (0, 0, 0, 0))
-        draw = ImageDraw.Draw(img)
-        
-        x_pos = 10
-        y_pos = img_height // 2
-        
-        for char in text:
-            char_code = ord(char)
-            if char_code in self.font_data:
-                vectors = self.font_data[char_code]
-                last_pos = None
-                
-                for vector in vectors:
-                    if vector['type'] == 1:  # Draw
-                        if last_pos:
-                            draw.line(
-                                [
-                                    (x_pos + last_pos[0] * scale,
-                                     y_pos - last_pos[1] * scale),
-                                    (x_pos + vector['x'] * scale,
-                                     y_pos - vector['y'] * scale)
-                                ],
-                                fill=color,
-                                width=max(1, int(scale / 4))
-                            )
-                        last_pos = (vector['x'], vector['y'])
-                    else:  # Move
-                        last_pos = (vector['x'], vector['y'])
-                
-                x_pos += size * 0.75  # Move to next character
-            else:
-                x_pos += size * 0.5  # Space for unknown characters
-        
-        return img
+    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")
 
-def main():
-    """Main function to run the application"""
-    app = TextToImageApp()
-    app.launch()
+    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
+    )
 
-if __name__ == "__main__":
-    main()	
+demo.launch()