Update app.py

app.py

@@ -1,7 +1,7 @@
 import gradio as gr
 import matplotlib.pyplot as plt
 from io import BytesIO
-from PIL import Image, ImageDraw, ImageFont
+from PIL import Image, ImageDraw, ImageFont, ImageFilter
 import textwrap
 import os
 import matplotlib
@@ -9,180 +9,504 @@ import math
 import zipfile
 import tempfile
 import shutil
+import numpy as np
+from typing import Dict, List, Tuple, Optional
+import re
 
-# Create a fonts directory in temp
+# Constants
 FONTS_DIR = os.path.join(tempfile.gettempdir(), 'text_to_image_fonts')
-os.makedirs(FONTS_DIR, exist_ok=True)
+SUPPORTED_FONT_TYPES = ('.ttf', '.otf', '.shx')
+DEFAULT_MARGIN = 10
 
-def extract_fonts_from_zip(zip_path):
-    """Extract TTF and SHX fonts from zip file"""
-    supported_extensions = ('.ttf', '.shx')
-    font_files = []
-    
-    with zipfile.ZipFile(zip_path, 'r') as zip_ref:
-        # Extract all font files
-        for file in zip_ref.namelist():
-            if file.lower().endswith(supported_extensions):
-                zip_ref.extract(file, FONTS_DIR)
-                font_files.append(os.path.join(FONTS_DIR, file))
-    
-    return font_files
-
-def get_all_fonts():
-    """Get system fonts and custom fonts"""
-    fonts = []
-    # System fonts
-    for font in matplotlib.font_manager.findSystemFonts(fontpaths=None, fontext='ttf'):
-        font_name = os.path.basename(font)
-        fonts.append({"name": font_name, "path": font, "type": "system"})
-    
-    # Custom fonts from FONTS_DIR
-    if os.path.exists(FONTS_DIR):
-        for font in os.listdir(FONTS_DIR):
-            if font.lower().endswith(('.ttf', '.shx')):
-                font_path = os.path.join(FONTS_DIR, font)
-                fonts.append({"name": font, "path": font_path, 
-                            "type": "custom_" + os.path.splitext(font)[1][1:]})
-    
-    return sorted(fonts, key=lambda x: (x["type"], x["name"]))
-
-def load_font(font_info, size):
-    """Load font based on type"""
-    if font_info["type"] == "custom_shx":
-        # Here you would implement SHX font loading
-        # For now, fallback to default
-        return ImageFont.load_default()
-    else:
+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_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 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:
-            return ImageFont.truetype(font_info["path"], size)
-        except Exception:
+            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 handle_font_upload(zip_file):
-    """Handle font zip file upload"""
-    if zip_file is not None:
-        extracted_fonts = extract_fonts_from_zip(zip_file.name)
-        return gr.Dropdown.update(choices=[f["name"] for f in get_all_fonts()])
-    return gr.Dropdown.update()
+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)
 
-def create_text_segment(lines, start_idx, max_lines, width, height, bg_color, text_color, font_info, font_size, align, margin, text_effects):
-    img = Image.new("RGBA", (width, height), color=bg_color)
-    draw = ImageDraw.Draw(img)
-    
-    font = load_font(font_info, 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 text effects
-        if 'shadow' in text_effects:
-            shadow_offset = 2
-            draw.text((x + shadow_offset, y + shadow_offset), line, 
-                     fill=(0, 0, 0, 128), font=font)
-        
-        if 'outline' in text_effects:
-            outline_color = (0, 0, 0, 255)
-            for off_x, off_y in [(1,0), (-1,0), (0,1), (0,-1)]:
-                draw.text((x + off_x, y + off_y), line, 
-                         fill=outline_color, font=font)
-        
-        draw.text((x, y), line, fill=text_color, font=font)
-        y += line_height
-    
-    return img, end_idx
+    @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)
 
-def text_to_image(input_text, font_size, width, height, bg_color, text_color, 
-                 mode, font_name, align, image_format, text_effects, opacity):
-    # Convert colors to RGBA
-    bg_color = (*parse_color(bg_color), int(opacity * 255))
-    text_color = (*parse_color(text_color), 255)
-    
-    # Get font info
-    font_list = get_all_fonts()
-    font_info = next((f for f in font_list if f["name"] == font_name), None)
-    if not font_info:
-        font_info = {"name": "default", "path": None, "type": "system"}
-    
-    if mode == "Plain Text":
-        img = render_plain_text_image(input_text, font_size, width, height, 
-                                    bg_color, text_color, font_info, align, 
-                                    text_effects, opacity)
-    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
+    @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)
 
-# Update the Gradio interface
-with gr.Blocks() as demo:
-    gr.Markdown("# 🖼️ Enhanced 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)
-        file_input = gr.File(label="Upload a Text File", type="filepath")
-    
-    with gr.Row():
-        font_size = gr.Slider(10, 100, value=30, label="Font Size")
-        font_name = gr.Dropdown(choices=[f["name"] for f in get_all_fonts()], 
-                              label="Font")
-        align = gr.Radio(["Left", "Center", "Right"], 
-                        label="Text Alignment", value="Center")
-    
-    with gr.Row():
-        text_effects = gr.CheckboxGroup(
-            ["shadow", "outline"], 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")
+class TextRenderer:
+    def __init__(self):
+        self.font_manager = FontManager()
+
+    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
+
+    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
+
+    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
+
+    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
+
+    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)
+
+class TextToImageApp:
+    def __init__(self):
+        self.renderer = TextRenderer()
+        self.setup_interface()
+
+    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()
+
+    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
+
+    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
+            )
+
+    def launch(self):
+        """Launch the Gradio interface"""
+        self.demo.launch()
+
+
+class SHXFontRenderer:
+    """SHX Font Renderer for AutoCAD SHX fonts"""
     
-    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")
+    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
     
-    output_image = gr.Image(label="Generated Image")
+    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
     
-    # Connect components
-    font_upload.upload(handle_font_upload, 
-                      inputs=[font_upload], 
-                      outputs=[font_name])
+    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
     
-    convert_button = gr.Button("Convert Text 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, text_effects, opacity
-        ],
-        outputs=output_image
-    )
-
-demo.launch()
+    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
+
+
+def main():
+    """Main function to run the application"""
+    app = TextToImageApp()
+    app.launch()
+
+
+if __name__ == "__main__":
+    main()