refactor text_overlay.py

app.py

@@ -3,8 +3,7 @@ import requests
 from PIL import Image, ImageDraw, ImageFont
 import io
 import openai
-import base64
-from io import BytesIO
+from text_overlay import create_pattern_template, get_pattern_template, add_text_to_image, get_font_path
 
 # Image Generation Functions
 def generate_ideogram_image(api_key, prompt, aspect_ratio="ASPECT_1_1"):
@@ -79,234 +78,6 @@ def process_uploaded_image(image):
         print(f"Error processing uploaded image: {e}")
         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, 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}")
-    
-    if img is None:
-        print("ERROR: No image provided")
-        return None, "Please supply an image first."
-
-    try:
-        # Create a working copy
-        print(f"Original image mode: {img.mode}, size: {img.size}")
-        image = img.convert("RGB")
-        print(f"Converted image mode: {image.mode}")
-        draw = ImageDraw.Draw(image)
-        print("ImageDraw created successfully")
-
-        # UPDATED: Use selected font instead of hardcoded paths
-        font = get_font_path(font_name, font_size)
-        if font is None:
-            return None, f"Could not load font: {font_name}"
-
-        w, h = image.size
-        print(f"Image dimensions: {w}x{h}")
-        
-        # Pattern matching (same as before)
-        positions = []
-        detected_pattern = "unknown"
-        
-        pattern_lower = pattern.lower()
-        
-        if ("2-lines-top" in pattern_lower) or ("2 lines - top" in pattern_lower):
-            positions = [(w // 2, int(h * 0.10)), (w // 2, int(h * 0.20))]
-            detected_pattern = "2-lines-top"
-        elif ("2-lines-bottom" in pattern_lower) or ("2 lines - bottom" in pattern_lower):
-            positions = [(w // 2, int(h * 0.80)), (w // 2, int(h * 0.90))]
-            detected_pattern = "2-lines-bottom"
-        elif ("2-lines-center" in pattern_lower) or ("2 lines - center" in pattern_lower):
-            positions = [(w // 2, int(h * 0.45)), (w // 2, int(h * 0.55))]
-            detected_pattern = "2-lines-center"
-        elif ("3-lines-top" in pattern_lower) or ("3 lines - top" in pattern_lower):
-            positions = [(w // 2, int(h * 0.10)), (w // 2, int(h * 0.20)), (w // 2, int(h * 0.30))]
-            detected_pattern = "3-lines-top"
-        elif ("3-lines-center" in pattern_lower) or ("3 lines - center" in pattern_lower):
-            positions = [(w // 2, int(h * 0.40)), (w // 2, int(h * 0.50)), (w // 2, int(h * 0.60))]
-            detected_pattern = "3-lines-center"
-        elif ("3-lines-bottom" in pattern_lower) or ("3 lines - bottom" in pattern_lower):
-            positions = [(w // 2, int(h * 0.70)), (w // 2, int(h * 0.80)), (w // 2, int(h * 0.90))]
-            detected_pattern = "3-lines-bottom"
-        else:
-            print(f"WARNING: Unknown pattern '{pattern}', using 2-lines-center as default")
-            positions = [(w // 2, int(h * 0.45)), (w // 2, int(h * 0.55))]
-            detected_pattern = "2-lines-center (default)"
-            
-        print(f"Detected pattern: {detected_pattern}")
-        print(f"Text positions calculated: {positions}")
-
-        # Color parsing (same as before)
-        original_color = color
-        final_color = (255, 255, 255)
-        
-        if isinstance(color, str):
-            if color.startswith('rgba(') and color.endswith(')'):
-                print(f"Parsing RGBA string: {color}")
-                try:
-                    rgba_part = color[5:-1]
-                    values = [float(x.strip()) for x in rgba_part.split(',')]
-                    if len(values) >= 3:
-                        final_color = (int(round(values[0])), int(round(values[1])), int(round(values[2])))
-                        print(f"Successfully parsed RGBA {color} to RGB: {final_color}")
-                except (ValueError, IndexError) as e:
-                    print(f"Error parsing RGBA {color}: {e}, using white")
-                    final_color = (255, 255, 255)
-            elif color.startswith('#'):
-                print(f"Converting hex color {color}")
-                hex_color = color.lstrip('#')
-                if len(hex_color) == 6:
-                    try:
-                        final_color = tuple(int(hex_color[i:i+2], 16) for i in (0, 2, 4))
-                        print(f"Successfully converted hex {color} to RGB: {final_color}")
-                    except ValueError as e:
-                        print(f"Invalid hex color {color}: {e}, using white")
-                        final_color = (255, 255, 255)
-        
-        print(f"Final color for drawing: {final_color}")
-        
-        # Draw text (same logic as before)
-        lines = [line1, line2, line3]
-        print(f"All input lines: {lines}")
-        
-        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")
-        
-        text_drawn = False
-        
-        for i, ((x, y), txt) in enumerate(active_lines):
-            print(f"Drawing line {i+1}: '{txt}' at position ({x}, {y}) with font {font_name}")
-            
-            # Optional outline/stroke
-            if add_outline:
-                stroke_width = max(1, font_size // 20)
-                print(f"Adding outline with stroke width: {stroke_width}")
-                
-                # Draw text outline (black)
-                for dx in [-stroke_width, 0, stroke_width]:
-                    for dy in [-stroke_width, 0, stroke_width]:
-                        if dx != 0 or dy != 0:
-                            try:
-                                draw.text((x + dx, y + dy), txt, fill=(0, 0, 0), font=font, anchor="mm")
-                            except TypeError:
-                                try:
-                                    bbox = draw.textbbox((0, 0), txt, font=font)
-                                    text_w = bbox[2] - bbox[0]
-                                    text_h = bbox[3] - bbox[1]
-                                    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)
-            
-            # Draw main text
-            try:
-                draw.text((x, y), txt, fill=final_color, font=font, anchor="mm")
-                print(f"SUCCESS: Main text drawn with {font_name} at ({x}, {y})")
-            except TypeError:
-                try:
-                    bbox = draw.textbbox((0, 0), txt, font=font)
-                    text_w = bbox[2] - bbox[0]
-                    text_h = bbox[3] - bbox[1]
-                    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 {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 {font_name} at ({x}, {y})")
-            
-            text_drawn = True
-            print(f"Completed drawing line {i+1}")
-
-        if not text_drawn:
-            print("No text was drawn - all lines were empty")
-            return img, "No text to add (all lines were empty)"
-        
-        print("=== Text drawing completed successfully ===")
-        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}")
-        import traceback
-        traceback.print_exc()
-        return None, f"Error adding text: {str(e)}"
-
-def test_text_overlay():
-    """Test function to verify text overlay works"""
-    print("=== Testing basic text overlay ===")
-    try:
-        # Create a simple test image
-        from PIL import Image, ImageDraw, ImageFont
-        test_img = Image.new('RGB', (400, 300), color='blue')
-        draw = ImageDraw.Draw(test_img)
-        
-        # Try to draw simple text
-        try:
-            font = ImageFont.load_default()
-            draw.text((200, 150), "TEST", fill='white', font=font, anchor="mm")
-            print("Basic text drawing works!")
-            return test_img, "Test successful", None
-        except Exception as e:
-            print(f"Basic text drawing failed: {e}")
-            draw.text((50, 100), "TEST", fill='white')
-            print("Fallback text drawing works!")
-            return test_img, "Test with fallback", None
-            
-    except Exception as e:
-        print(f"Test failed completely: {e}")
-        return None, f"Test failed: {e}", None
-
-# Function to create template images
-def create_pattern_template(pattern, width=200, height=120):
-    """Create a visual template showing text placement for each pattern"""
-    # Create black background
-    img = Image.new('RGB', (width, height), color='black')
-    draw = ImageDraw.Draw(img)
-    
-    # Define positions based on pattern
-    positions = []
-    if pattern == "2-lines-top":
-        positions = [(width // 2, int(height * 0.15)), (width // 2, int(height * 0.35))]
-    elif pattern == "2-lines-center":
-        positions = [(width // 2, int(height * 0.35)), (width // 2, int(height * 0.65))]
-    elif pattern == "2-lines-bottom":
-        positions = [(width // 2, int(height * 0.65)), (width // 2, int(height * 0.85))]
-    elif pattern == "3-lines-top":
-        positions = [(width // 2, int(height * 0.15)), (width // 2, int(height * 0.35)), (width // 2, int(height * 0.55))]
-    elif pattern == "3-lines-center":
-        positions = [(width // 2, int(height * 0.25)), (width // 2, int(height * 0.50)), (width // 2, int(height * 0.75))]
-    elif pattern == "3-lines-bottom":
-        positions = [(width // 2, int(height * 0.45)), (width // 2, int(height * 0.65)), (width // 2, int(height * 0.85))]
-    
-    # Draw white rectangles to represent text boxes
-    for i, (x, y) in enumerate(positions):
-        # Draw white rectangle as text placeholder
-        box_width = 60
-        box_height = 12
-        left = x - box_width // 2
-        top = y - box_height // 2
-        right = x + box_width // 2
-        bottom = y + box_height // 2
-        
-        draw.rectangle([left, top, right, bottom], fill='white', outline='white')
-    
-    return img
-
-# Create templates
-def get_pattern_template(pattern):
-    """Get template for pattern - create on demand to avoid initialization issues"""
-    return create_pattern_template(pattern)
-
 # Fix the image passing with better error handling
 def safe_image_copy(img):
     """Safely copy an image to avoid corruption issues"""
@@ -328,100 +99,6 @@ def safe_image_copy(img):
         print(f"Error copying image: {e}")
         return img
 
-# Function to convert PIL image to base64 for Gradio
-def pil_to_base64(img):
-    """Convert PIL image to base64 string for Gradio"""
-    buffer = BytesIO()
-    img.save(buffer, format='PNG')
-    img_str = base64.b64encode(buffer.getvalue()).decode()
-    return f"data:image/png;base64,{img_str}"
-
-# Create all template images
-pattern_templates = {}
-pattern_names = ["2-lines-top", "2-lines-center", "2-lines-bottom", "3-lines-top", "3-lines-center", "3-lines-bottom"]
-
-for pattern in pattern_names:
-    template_img = create_pattern_template(pattern)
-    pattern_templates[pattern] = template_img
-
-# Function to update template display
-def update_pattern_template(selected_pattern):
-    """Return the template image for the selected pattern"""
-    if selected_pattern in pattern_templates:
-        return pattern_templates[selected_pattern]
-    else:
-        # 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", 
-            "/usr/share/fonts/truetype/liberation/LiberationSans-Bold.ttf",
-            "/usr/share/fonts/truetype/dejavu/DejaVuSans-Bold.ttf"
-        ],
-        "Arial Bold": [
-            "/usr/share/fonts/truetype/liberation/LiberationSans-Bold.ttf",
-            "/usr/share/fonts/truetype/dejavu/DejaVuSans-Bold.ttf",
-            "arial-bold.ttf"
-        ],
-        "Times Bold": [
-            "/usr/share/fonts/truetype/liberation/LiberationSerif-Bold.ttf",
-            "/usr/share/fonts/truetype/dejavu/DejaVuSerif-Bold.ttf",
-            "times-bold.ttf"
-        ],
-        "Comic Sans": [
-            "/usr/share/fonts/truetype/dejavu/DejaVuSans.ttf",
-            "/usr/share/fonts/truetype/liberation/LiberationSans-Regular.ttf",
-            "comic.ttf"
-        ],
-        "Bebas Neue": [
-            "/usr/share/fonts/truetype/dejavu/DejaVuSansCondensed-Bold.ttf", 
-            "/usr/share/fonts/truetype/liberation/LiberationSans-Bold.ttf",
-            "bebas-neue.ttf"
-        ]
-    }
-    
-    # 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")
@@ -609,17 +286,6 @@ with gr.Blocks(title="AI Image Generator & Text Overlay") as demo:
             outputs=[text_image, status_message]
         )
 
-        # In the Text Overlay tab, add this button for testing:
-        with gr.Row():
-            test_btn = gr.Button("🔧 Test Text Overlay", variant="secondary")
-
-        # Add this event handler:
-        test_btn.click(
-            test_text_overlay,
-            inputs=[],
-            outputs=[text_image, status_message]
-        )
-
     # FIXED: Move demo.load() INSIDE the Blocks context
     demo.load(
         lambda: get_pattern_template("2-lines-top"),

text_overlay.py

@@ -0,0 +1,272 @@
+from PIL import Image, ImageDraw, ImageFont
+
+# 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", 
+            "/usr/share/fonts/truetype/liberation/LiberationSans-Bold.ttf",
+            "/usr/share/fonts/truetype/dejavu/DejaVuSans-Bold.ttf"
+        ],
+        "Arial Bold": [
+            "/usr/share/fonts/truetype/liberation/LiberationSans-Bold.ttf",
+            "/usr/share/fonts/truetype/dejavu/DejaVuSans-Bold.ttf",
+            "arial-bold.ttf"
+        ],
+        "Times Bold": [
+            "/usr/share/fonts/truetype/liberation/LiberationSerif-Bold.ttf",
+            "/usr/share/fonts/truetype/dejavu/DejaVuSerif-Bold.ttf",
+            "times-bold.ttf"
+        ],
+        "Comic Sans": [
+            "/usr/share/fonts/truetype/dejavu/DejaVuSans.ttf",
+            "/usr/share/fonts/truetype/liberation/LiberationSans-Regular.ttf",
+            "comic.ttf"
+        ],
+        "Bebas Neue": [
+            "/usr/share/fonts/truetype/dejavu/DejaVuSansCondensed-Bold.ttf", 
+            "/usr/share/fonts/truetype/liberation/LiberationSans-Bold.ttf",
+            "bebas-neue.ttf"
+        ]
+    }
+    
+    # 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
+
+# Function to create template images
+def create_pattern_template(pattern, width=200, height=120):
+    """Create a visual template showing text placement for each pattern"""
+    # Create black background
+    img = Image.new('RGB', (width, height), color='black')
+    draw = ImageDraw.Draw(img)
+    
+    # Define positions based on pattern
+    positions = []
+    if pattern == "2-lines-top":
+        positions = [(width // 2, int(height * 0.15)), (width // 2, int(height * 0.35))]
+    elif pattern == "2-lines-center":
+        positions = [(width // 2, int(height * 0.35)), (width // 2, int(height * 0.65))]
+    elif pattern == "2-lines-bottom":
+        positions = [(width // 2, int(height * 0.65)), (width // 2, int(height * 0.85))]
+    elif pattern == "3-lines-top":
+        positions = [(width // 2, int(height * 0.15)), (width // 2, int(height * 0.35)), (width // 2, int(height * 0.55))]
+    elif pattern == "3-lines-center":
+        positions = [(width // 2, int(height * 0.25)), (width // 2, int(height * 0.50)), (width // 2, int(height * 0.75))]
+    elif pattern == "3-lines-bottom":
+        positions = [(width // 2, int(height * 0.45)), (width // 2, int(height * 0.65)), (width // 2, int(height * 0.85))]
+    
+    # Draw white rectangles to represent text boxes
+    for i, (x, y) in enumerate(positions):
+        # Draw white rectangle as text placeholder
+        box_width = 60
+        box_height = 12
+        left = x - box_width // 2
+        top = y - box_height // 2
+        right = x + box_width // 2
+        bottom = y + box_height // 2
+        
+        draw.rectangle([left, top, right, bottom], fill='white', outline='white')
+    
+    return img
+
+def get_pattern_template(pattern):
+    """Get template for pattern - create on demand to avoid initialization issues"""
+    return create_pattern_template(pattern)
+
+# Text Overlay Functions
+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}")
+    
+    if img is None:
+        print("ERROR: No image provided")
+        return None, "Please supply an image first."
+
+    try:
+        # Create a working copy
+        print(f"Original image mode: {img.mode}, size: {img.size}")
+        image = img.convert("RGB")
+        print(f"Converted image mode: {image.mode}")
+        draw = ImageDraw.Draw(image)
+        print("ImageDraw created successfully")
+
+        # UPDATED: Use selected font instead of hardcoded paths
+        font = get_font_path(font_name, font_size)
+        if font is None:
+            return None, f"Could not load font: {font_name}"
+
+        w, h = image.size
+        print(f"Image dimensions: {w}x{h}")
+        
+        # Pattern matching (same as before)
+        positions = []
+        detected_pattern = "unknown"
+        
+        pattern_lower = pattern.lower()
+        
+        if ("2-lines-top" in pattern_lower) or ("2 lines - top" in pattern_lower):
+            positions = [(w // 2, int(h * 0.10)), (w // 2, int(h * 0.20))]
+            detected_pattern = "2-lines-top"
+        elif ("2-lines-bottom" in pattern_lower) or ("2 lines - bottom" in pattern_lower):
+            positions = [(w // 2, int(h * 0.80)), (w // 2, int(h * 0.90))]
+            detected_pattern = "2-lines-bottom"
+        elif ("2-lines-center" in pattern_lower) or ("2 lines - center" in pattern_lower):
+            positions = [(w // 2, int(h * 0.45)), (w // 2, int(h * 0.55))]
+            detected_pattern = "2-lines-center"
+        elif ("3-lines-top" in pattern_lower) or ("3 lines - top" in pattern_lower):
+            positions = [(w // 2, int(h * 0.10)), (w // 2, int(h * 0.20)), (w // 2, int(h * 0.30))]
+            detected_pattern = "3-lines-top"
+        elif ("3-lines-center" in pattern_lower) or ("3 lines - center" in pattern_lower):
+            positions = [(w // 2, int(h * 0.40)), (w // 2, int(h * 0.50)), (w // 2, int(h * 0.60))]
+            detected_pattern = "3-lines-center"
+        elif ("3-lines-bottom" in pattern_lower) or ("3 lines - bottom" in pattern_lower):
+            positions = [(w // 2, int(h * 0.70)), (w // 2, int(h * 0.80)), (w // 2, int(h * 0.90))]
+            detected_pattern = "3-lines-bottom"
+        else:
+            print(f"WARNING: Unknown pattern '{pattern}', using 2-lines-center as default")
+            positions = [(w // 2, int(h * 0.45)), (w // 2, int(h * 0.55))]
+            detected_pattern = "2-lines-center (default)"
+            
+        print(f"Detected pattern: {detected_pattern}")
+        print(f"Text positions calculated: {positions}")
+
+        # Color parsing (same as before)
+        original_color = color
+        final_color = (255, 255, 255)
+        
+        if isinstance(color, str):
+            if color.startswith('rgba(') and color.endswith(')'):
+                print(f"Parsing RGBA string: {color}")
+                try:
+                    rgba_part = color[5:-1]
+                    values = [float(x.strip()) for x in rgba_part.split(',')]
+                    if len(values) >= 3:
+                        final_color = (int(round(values[0])), int(round(values[1])), int(round(values[2])))
+                        print(f"Successfully parsed RGBA {color} to RGB: {final_color}")
+                except (ValueError, IndexError) as e:
+                    print(f"Error parsing RGBA {color}: {e}, using white")
+                    final_color = (255, 255, 255)
+            elif color.startswith('#'):
+                print(f"Converting hex color {color}")
+                hex_color = color.lstrip('#')
+                if len(hex_color) == 6:
+                    try:
+                        final_color = tuple(int(hex_color[i:i+2], 16) for i in (0, 2, 4))
+                        print(f"Successfully converted hex {color} to RGB: {final_color}")
+                    except ValueError as e:
+                        print(f"Invalid hex color {color}: {e}, using white")
+                        final_color = (255, 255, 255)
+        
+        print(f"Final color for drawing: {final_color}")
+        
+        # Draw text (same logic as before)
+        lines = [line1, line2, line3]
+        print(f"All input lines: {lines}")
+        
+        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")
+        
+        text_drawn = False
+        
+        for i, ((x, y), txt) in enumerate(active_lines):
+            print(f"Drawing line {i+1}: '{txt}' at position ({x}, {y}) with font {font_name}")
+            
+            # Optional outline/stroke
+            if add_outline:
+                stroke_width = max(1, font_size // 20)
+                print(f"Adding outline with stroke width: {stroke_width}")
+                
+                # Draw text outline (black)
+                for dx in [-stroke_width, 0, stroke_width]:
+                    for dy in [-stroke_width, 0, stroke_width]:
+                        if dx != 0 or dy != 0:
+                            try:
+                                draw.text((x + dx, y + dy), txt, fill=(0, 0, 0), font=font, anchor="mm")
+                            except TypeError:
+                                try:
+                                    bbox = draw.textbbox((0, 0), txt, font=font)
+                                    text_w = bbox[2] - bbox[0]
+                                    text_h = bbox[3] - bbox[1]
+                                    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)
+            
+            # Draw main text
+            try:
+                draw.text((x, y), txt, fill=final_color, font=font, anchor="mm")
+                print(f"SUCCESS: Main text drawn with {font_name} at ({x}, {y})")
+            except TypeError:
+                try:
+                    bbox = draw.textbbox((0, 0), txt, font=font)
+                    text_w = bbox[2] - bbox[0]
+                    text_h = bbox[3] - bbox[1]
+                    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 {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 {font_name} at ({x}, {y})")
+            
+            text_drawn = True
+            print(f"Completed drawing line {i+1}")
+
+        if not text_drawn:
+            print("No text was drawn - all lines were empty")
+            return img, "No text to add (all lines were empty)"
+        
+        print("=== Text drawing completed successfully ===")
+        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}")
+        import traceback
+        traceback.print_exc()
+        return None, f"Error adding text: {str(e)}"