Adding logs

app.py

@@ -75,102 +75,191 @@ def process_uploaded_image(image):
 # Text Overlay Functions
 def add_text_to_image(img, pattern, line1, line2, line3, font_size, color):
     """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"Color: {color!r}")
+    
     if img is None:
+        print("ERROR: No image provided")
         return None, "Please supply an image first."
 
-    # Create a working copy
-    image = img.convert("RGB")  # Ensure RGB mode
-    draw = ImageDraw.Draw(image)
-
-    # More robust font loading with better fallbacks
-    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",
-    ]
-    
-    for font_path in font_paths:
-        try:
-            font = ImageFont.truetype(font_path, font_size)
-            break
-        except (OSError, IOError):
-            continue
-    
-    # Final fallback to default font
-    if font is None:
-        try:
-            font = ImageFont.load_default()
-        except Exception:
-            # Create a basic font if all else fails
-            font = ImageFont.load_default()
+    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")
 
-    w, h = image.size
-    positions = []
-    
-    # Define text positioning patterns
-    if pattern == "2-lines-top":
-        positions = [(w // 2, int(h * 0.10)), (w // 2, int(h * 0.20))]
-    elif pattern == "2-lines-bottom":
-        positions = [(w // 2, int(h * 0.80)), (w // 2, int(h * 0.90))]
-    elif pattern == "2-lines-center":
-        positions = [(w // 2, int(h * 0.45)), (w // 2, int(h * 0.55))]
-    elif pattern == "3-lines-center":
-        positions = [(w // 2, int(h * 0.40)), (w // 2, int(h * 0.50)), (w // 2, int(h * 0.60))]
-    elif pattern == "3-lines-top":
-        positions = [(w // 2, int(h * 0.10)), (w // 2, int(h * 0.20)), (w // 2, int(h * 0.30))]
-    elif pattern == "3-lines-bottom":
-        positions = [(w // 2, int(h * 0.70)), (w // 2, int(h * 0.80)), (w // 2, int(h * 0.90))]
+        # More robust font loading with better fallbacks
+        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
+        
+        # Final fallback to default font
+        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}"
 
-    # Convert hex color to RGB tuple if needed
-    if isinstance(color, str) and color.startswith('#'):
-        # Convert hex to RGB
-        color = color.lstrip('#')
-        if len(color) == 6:
-            color = tuple(int(color[i:i+2], 16) for i in (0, 2, 4))
+        w, h = image.size
+        print(f"Image dimensions: {w}x{h}")
+        positions = []
+        
+        # Define text positioning patterns
+        if pattern == "2-lines-top":
+            positions = [(w // 2, int(h * 0.10)), (w // 2, int(h * 0.20))]
+        elif pattern == "2-lines-bottom":
+            positions = [(w // 2, int(h * 0.80)), (w // 2, int(h * 0.90))]
+        elif pattern == "2-lines-center":
+            positions = [(w // 2, int(h * 0.45)), (w // 2, int(h * 0.55))]
+        elif pattern == "3-lines-center":
+            positions = [(w // 2, int(h * 0.40)), (w // 2, int(h * 0.50)), (w // 2, int(h * 0.60))]
+        elif pattern == "3-lines-top":
+            positions = [(w // 2, int(h * 0.10)), (w // 2, int(h * 0.20)), (w // 2, int(h * 0.30))]
+        elif pattern == "3-lines-bottom":
+            positions = [(w // 2, int(h * 0.70)), (w // 2, int(h * 0.80)), (w // 2, int(h * 0.90))]
         else:
-            color = (255, 255, 255)  # Default to white
-    
-    # Draw text with better visibility
-    lines = [line1, line2, line3][:len(positions)]
-    text_drawn = False
-    
-    for (x, y), txt in zip(positions, lines):
-        if txt and txt.strip():
-            # Add text stroke/outline for better visibility
-            stroke_width = max(1, font_size // 20)
+            print(f"WARNING: Unknown pattern '{pattern}', using default")
+            positions = [(w // 2, int(h * 0.50))]
             
-            # 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:
+        print(f"Text positions calculated: {positions}")
+
+        # Convert hex color to RGB tuple if needed
+        original_color = color
+        if isinstance(color, str) and color.startswith('#'):
+            print(f"Converting hex color {color}")
+            color = color.lstrip('#')
+            if len(color) == 6:
+                color = tuple(int(color[i:i+2], 16) for i in (0, 2, 4))
+                print(f"Converted to RGB: {color}")
+            else:
+                print("Invalid hex color, using white")
+                color = (255, 255, 255)
+        elif isinstance(color, str):
+            print(f"Non-hex color string: {color}, using white")
+            color = (255, 255, 255)
+        
+        # Draw text with better visibility
+        lines = [line1, line2, line3][:len(positions)]
+        print(f"Active lines: {lines}")
+        text_drawn = False
+        
+        for i, ((x, y), txt) in enumerate(zip(positions, lines)):
+            if txt and txt.strip():
+                print(f"Drawing line {i+1}: '{txt}' at position ({x}, {y})")
+                
+                # Add text stroke/outline for better visibility
+                stroke_width = max(1, font_size // 20)
+                print(f"Using stroke width: {stroke_width}")
+                
+                try:
+                    # 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 as e:
+                                    print(f"Anchor not supported: {e}, using fallback")
+                                    # Fallback for older PIL versions without anchor
+                                    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 as bbox_e:
+                                        print(f"Textbbox also failed: {bbox_e}, using basic positioning")
+                                        draw.text((x + dx, y + dy), txt, fill=(0, 0, 0), font=font)
+                    
+                    # Draw main text
+                    try:
+                        draw.text((x, y), txt, fill=color, font=font, anchor="mm")
+                        print(f"Main text drawn with anchor at ({x}, {y})")
+                    except TypeError as e:
+                        print(f"Anchor not supported for main text: {e}, using fallback")
+                        # Fallback for older PIL versions
                         try:
-                            draw.text((x + dx, y + dy), txt, fill=(0, 0, 0), font=font, anchor="mm")
-                        except TypeError:
-                            # Fallback for older PIL versions without anchor
                             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)
-            
-            # Draw main text
-            try:
-                draw.text((x, y), txt, fill=color, font=font, anchor="mm")
-            except TypeError:
-                # Fallback for older PIL versions
-                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, y - text_h//2), txt, fill=color, font=font)
-            
-            text_drawn = True
+                            fallback_x = x - text_w//2
+                            fallback_y = y - text_h//2
+                            draw.text((fallback_x, fallback_y), txt, fill=color, font=font)
+                            print(f"Fallback text drawn at ({fallback_x}, {fallback_y})")
+                        except Exception as bbox_e:
+                            print(f"Textbbox also failed: {bbox_e}, using basic positioning")
+                            draw.text((x, y), txt, fill=color, font=font)
+                    
+                    text_drawn = True
+                    print(f"Successfully drew line {i+1}")
+                    
+                except Exception as e:
+                    print(f"ERROR drawing text line {i+1}: {e}")
+                    import traceback
+                    traceback.print_exc()
+            else:
+                print(f"Skipping empty line {i+1}")
 
-    if not text_drawn:
-        return img, "No text to add (all lines were empty)"
-    
-    return image, f"Text added successfully! Font size: {font_size}, Color: {color}"
+        if not text_drawn:
+            print("No text was drawn")
+            return img, "No text to add (all lines were empty)"
+        
+        print("=== Text drawing completed ===")
+        print(f"Returning image with mode: {image.mode}, size: {image.size}")
+        return image, f"Text added! Pattern: {pattern}, Font: {font_size}px, Color: {original_color}, Lines drawn: {sum(1 for line in lines if line and line.strip())}"
+        
+    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"
+        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"
+            
+    except Exception as e:
+        print(f"Test failed completely: {e}")
+        return None, f"Test failed: {e}"
 
 # Create the Gradio Interface
 with gr.Blocks(title="AI Image Generator & Text Overlay") as demo:
@@ -311,6 +400,17 @@ 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]
+        )
+
 # Launch the application
 if __name__ == "__main__":
     demo.launch(