Added font selector

app.py

@@ -80,13 +80,14 @@ def process_uploaded_image(image):
         return image, f"Image uploaded with warning: {e}", image
 
 # Text Overlay Functions
-def add_text_to_image(img, pattern, line1, line2, line3, font_size, color, add_outline):
+def add_text_to_image(img, pattern, line1, line2, line3, font_size, color, add_outline, font_name):
     """Overlay 2- or 3-line text on the image in a preset layout."""
     print("=== DEBUG: add_text_to_image called ===")
     print(f"Input image: {type(img)}")
     print(f"Pattern: {pattern}")
     print(f"Lines: [{line1!r}, {line2!r}, {line3!r}]")
     print(f"Font size: {font_size}")
+    print(f"Font name: {font_name}")
     print(f"Color: {color!r}")
     print(f"Add outline: {add_outline}")
     
@@ -102,42 +103,18 @@ def add_text_to_image(img, pattern, line1, line2, line3, font_size, color, add_o
         draw = ImageDraw.Draw(image)
         print("ImageDraw created successfully")
 
-        # Font loading (same as before)
-        font = None
-        font_paths = [
-            "DejaVuSans-Bold.ttf",
-            "arial.ttf", 
-            "/System/Library/Fonts/Arial.ttf",
-            "/usr/share/fonts/truetype/dejavu/DejaVuSans-Bold.ttf",
-            "/usr/share/fonts/TTF/arial.ttf",
-        ]
-        
-        print("Attempting to load fonts...")
-        for i, font_path in enumerate(font_paths):
-            try:
-                font = ImageFont.truetype(font_path, font_size)
-                print(f"SUCCESS: Loaded font {font_path}")
-                break
-            except (OSError, IOError) as e:
-                print(f"FAILED: Font {font_path} - {e}")
-                continue
-        
+        # UPDATED: Use selected font instead of hardcoded paths
+        font = get_font_path(font_name, font_size)
         if font is None:
-            try:
-                font = ImageFont.load_default()
-                print("Using default font as fallback")
-            except Exception as e:
-                print(f"ERROR: Even default font failed: {e}")
-                return None, f"Font loading error: {e}"
+            return None, f"Could not load font: {font_name}"
 
         w, h = image.size
         print(f"Image dimensions: {w}x{h}")
         
-        # ROBUST pattern matching - handle both simple names and descriptive text
+        # Pattern matching (same as before)
         positions = []
         detected_pattern = "unknown"
         
-        # Normalize pattern string for matching
         pattern_lower = pattern.lower()
         
         if ("2-lines-top" in pattern_lower) or ("2 lines - top" in pattern_lower):
@@ -166,45 +143,23 @@ def add_text_to_image(img, pattern, line1, line2, line3, font_size, color, add_o
         print(f"Detected pattern: {detected_pattern}")
         print(f"Text positions calculated: {positions}")
 
-        # FIXED: Parse RGBA string from Gradio ColorPicker
+        # Color parsing (same as before)
         original_color = color
-        final_color = (255, 255, 255)  # Default white
+        final_color = (255, 255, 255)
         
         if isinstance(color, str):
             if color.startswith('rgba(') and color.endswith(')'):
-                # Parse RGBA string: 'rgba(253.2203125, 3.331846217105286, 3.331846217105286, 1)'
                 print(f"Parsing RGBA string: {color}")
                 try:
-                    # Extract numbers from the string
-                    rgba_part = color[5:-1]  # Remove 'rgba(' and ')'
+                    rgba_part = color[5:-1]
                     values = [float(x.strip()) for x in rgba_part.split(',')]
                     if len(values) >= 3:
-                        # Convert to integers and take only RGB (ignore alpha)
                         final_color = (int(round(values[0])), int(round(values[1])), int(round(values[2])))
                         print(f"Successfully parsed RGBA {color} to RGB: {final_color}")
-                    else:
-                        print(f"Invalid RGBA format {color}, using white")
-                        final_color = (255, 255, 255)
                 except (ValueError, IndexError) as e:
                     print(f"Error parsing RGBA {color}: {e}, using white")
                     final_color = (255, 255, 255)
-            elif color.startswith('rgb(') and color.endswith(')'):
-                # Parse RGB string: 'rgb(253, 3, 3)'
-                print(f"Parsing RGB string: {color}")
-                try:
-                    rgb_part = color[4:-1]  # Remove 'rgb(' and ')'
-                    values = [float(x.strip()) for x in rgb_part.split(',')]
-                    if len(values) >= 3:
-                        final_color = (int(round(values[0])), int(round(values[1])), int(round(values[2])))
-                        print(f"Successfully parsed RGB {color} to RGB: {final_color}")
-                    else:
-                        print(f"Invalid RGB format {color}, using white")
-                        final_color = (255, 255, 255)
-                except (ValueError, IndexError) as e:
-                    print(f"Error parsing RGB {color}: {e}, using white")
-                    final_color = (255, 255, 255)
             elif color.startswith('#'):
-                # Parse hex color
                 print(f"Converting hex color {color}")
                 hex_color = color.lstrip('#')
                 if len(hex_color) == 6:
@@ -214,47 +169,24 @@ def add_text_to_image(img, pattern, line1, line2, line3, font_size, color, add_o
                     except ValueError as e:
                         print(f"Invalid hex color {color}: {e}, using white")
                         final_color = (255, 255, 255)
-                elif len(hex_color) == 3:
-                    try:
-                        final_color = tuple(int(hex_color[i]*2, 16) for i in range(3))
-                        print(f"Successfully converted short hex {color} to RGB: {final_color}")
-                    except ValueError as e:
-                        print(f"Invalid short hex color {color}: {e}, using white")
-                        final_color = (255, 255, 255)
-                else:
-                    print(f"Invalid hex color length {color}, using white")
-                    final_color = (255, 255, 255)
-            else:
-                # Try to use as named color
-                print(f"Attempting to use named color: {color}")
-                final_color = color  # Let PIL try to handle it
-        elif isinstance(color, (tuple, list)) and len(color) >= 3:
-            final_color = tuple(int(round(x)) for x in color[:3])
-            print(f"Using tuple/list color: {final_color}")
-        else:
-            print(f"Unrecognized color format: {color}, using white")
-            final_color = (255, 255, 255)
         
         print(f"Final color for drawing: {final_color}")
         
-        # Draw text - PROPERLY handle all lines
+        # Draw text (same logic as before)
         lines = [line1, line2, line3]
         print(f"All input lines: {lines}")
         
-        # Only use as many lines as we have positions, but process non-empty ones
         active_lines = []
         for i in range(len(positions)):
             if i < len(lines) and lines[i] and lines[i].strip():
                 active_lines.append((positions[i], lines[i].strip()))
         
         print(f"Active lines to draw: {len(active_lines)} out of {len(positions)} positions")
-        for i, (pos, text) in enumerate(active_lines):
-            print(f"  Line {i+1}: '{text}' at {pos}")
         
         text_drawn = False
         
         for i, ((x, y), txt) in enumerate(active_lines):
-            print(f"Drawing line {i+1}: '{txt}' at position ({x}, {y})")
+            print(f"Drawing line {i+1}: '{txt}' at position ({x}, {y}) with font {font_name}")
             
             # Optional outline/stroke
             if add_outline:
@@ -275,13 +207,11 @@ def add_text_to_image(img, pattern, line1, line2, line3, font_size, color, add_o
                                     draw.text((x - text_w//2 + dx, y - text_h//2 + dy), txt, fill=(0, 0, 0), font=font)
                                 except Exception:
                                     draw.text((x + dx, y + dy), txt, fill=(0, 0, 0), font=font)
-            else:
-                print("Skipping outline (disabled)")
             
             # Draw main text
             try:
                 draw.text((x, y), txt, fill=final_color, font=font, anchor="mm")
-                print(f"SUCCESS: Main text drawn with color {final_color} at ({x}, {y})")
+                print(f"SUCCESS: Main text drawn with {font_name} at ({x}, {y})")
             except TypeError:
                 try:
                     bbox = draw.textbbox((0, 0), txt, font=font)
@@ -290,10 +220,10 @@ def add_text_to_image(img, pattern, line1, line2, line3, font_size, color, add_o
                     fallback_x = x - text_w//2
                     fallback_y = y - text_h//2
                     draw.text((fallback_x, fallback_y), txt, fill=final_color, font=font)
-                    print(f"SUCCESS: Fallback text drawn with color {final_color} at ({fallback_x}, {fallback_y})")
+                    print(f"SUCCESS: Fallback text drawn with {font_name} at ({fallback_x}, {fallback_y})")
                 except Exception:
                     draw.text((x, y), txt, fill=final_color, font=font)
-                    print(f"SUCCESS: Basic text drawn with color {final_color} at ({x}, {y})")
+                    print(f"SUCCESS: Basic text drawn with {font_name} at ({x}, {y})")
             
             text_drawn = True
             print(f"Completed drawing line {i+1}")
@@ -303,7 +233,7 @@ def add_text_to_image(img, pattern, line1, line2, line3, font_size, color, add_o
             return img, "No text to add (all lines were empty)"
         
         print("=== Text drawing completed successfully ===")
-        return image, f"✅ {len(active_lines)} lines added! Pattern: {detected_pattern}"
+        return image, f"✅ {len(active_lines)} lines added! Font: {font_name}, Pattern: {detected_pattern}"
         
     except Exception as e:
         print(f"CRITICAL ERROR in add_text_to_image: {e}")
@@ -423,6 +353,81 @@ def update_pattern_template(selected_pattern):
         # Return default template
         return create_pattern_template("2-lines-top")
 
+# Add this function to get available fonts with fallbacks
+def get_font_path(font_name, font_size):
+    """Get font path for the selected font with fallbacks"""
+    font_mappings = {
+        "Impact": [
+            "impact.ttf",
+            "Impact.ttf", 
+            "/System/Library/Fonts/Impact.ttf",
+            "/usr/share/fonts/truetype/liberation/LiberationSans-Bold.ttf"
+        ],
+        "Arial Bold": [
+            "arial-bold.ttf",
+            "arialbd.ttf",
+            "Arial-Bold.ttf",
+            "/System/Library/Fonts/Arial Bold.ttf", 
+            "/usr/share/fonts/truetype/dejavu/DejaVuSans-Bold.ttf"
+        ],
+        "Times Bold": [
+            "times-bold.ttf",
+            "timesbd.ttf", 
+            "Times-Bold.ttf",
+            "/System/Library/Fonts/Times Bold.ttf",
+            "/usr/share/fonts/truetype/liberation/LiberationSerif-Bold.ttf"
+        ],
+        "Comic Sans": [
+            "comic.ttf",
+            "COMIC.TTF",
+            "Comic Sans MS.ttf",
+            "/System/Library/Fonts/Comic Sans MS.ttf",
+            "/usr/share/fonts/truetype/dejavu/DejaVuSans.ttf"
+        ],
+        "Bebas Neue": [
+            "bebas-neue.ttf",
+            "BebasNeue-Regular.ttf",
+            "/usr/share/fonts/truetype/dejavu/DejaVuSans-Bold.ttf"  # fallback
+        ]
+    }
+    
+    # Get font paths for the selected font
+    font_paths = font_mappings.get(font_name, [])
+    
+    # Try each path
+    for font_path in font_paths:
+        try:
+            font = ImageFont.truetype(font_path, font_size)
+            print(f"SUCCESS: Loaded {font_name} from {font_path}")
+            return font
+        except (OSError, IOError):
+            continue
+    
+    # If no specific font found, try default system fonts
+    default_paths = [
+        "DejaVuSans-Bold.ttf",
+        "arial.ttf", 
+        "/System/Library/Fonts/Arial.ttf",
+        "/usr/share/fonts/truetype/dejavu/DejaVuSans-Bold.ttf",
+    ]
+    
+    for font_path in default_paths:
+        try:
+            font = ImageFont.truetype(font_path, font_size)
+            print(f"FALLBACK: Loaded default font from {font_path} for {font_name}")
+            return font
+        except (OSError, IOError):
+            continue
+    
+    # Final fallback
+    try:
+        font = ImageFont.load_default()
+        print(f"FINAL FALLBACK: Using system default for {font_name}")
+        return font
+    except Exception:
+        print(f"ERROR: Could not load any font for {font_name}")
+        return None
+
 # Create the Gradio Interface
 with gr.Blocks(title="AI Image Generator & Text Overlay") as demo:
     gr.Markdown("# 🎨 AI Image Generator & Text Overlay")
@@ -565,6 +570,21 @@ with gr.Blocks(title="AI Image Generator & Text Overlay") as demo:
                         label="Text Color",
                         value="#FFFFFF"
                     )
+                    
+                # NEW: Font selector
+                with gr.Row():
+                    font_selector = gr.Dropdown(
+                        choices=[
+                            "Impact",           # Bold, condensed - great for memes
+                            "Arial Bold",       # Clean, readable
+                            "Times Bold",       # Classic, serif
+                            "Comic Sans",       # Casual, friendly
+                            "Bebas Neue"        # Modern, tall
+                        ],
+                        value="Impact",
+                        label="Font Style",
+                        info="Choose font for text overlay"
+                    )
                 
                 # Add outline option
                 add_outline = gr.Checkbox(
@@ -591,7 +611,7 @@ with gr.Blocks(title="AI Image Generator & Text Overlay") as demo:
         # Add text to image
         add_text_btn.click(
             add_text_to_image,
-            inputs=[current_image, pattern, line1_inp, line2_inp, line3_inp, font_size, color, add_outline],
+            inputs=[current_image, pattern, line1_inp, line2_inp, line3_inp, font_size, color, add_outline, font_selector],
             outputs=[text_image, status_message]
         )