updates app.py - fix pattern matching

app.py

@@ -132,25 +132,38 @@ def add_text_to_image(img, pattern, line1, line2, line3, font_size, color, add_o
 
         w, h = image.size
         print(f"Image dimensions: {w}x{h}")
+        
+        # ROBUST pattern matching - handle both simple names and descriptive text
         positions = []
+        detected_pattern = "unknown"
+        
+        # Normalize pattern string for matching
+        pattern_lower = pattern.lower()
         
-        # Define text positioning patterns
-        if pattern == "2-lines-top":
+        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))]
-        elif pattern == "2-lines-bottom":
+            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))]
-        elif pattern == "2-lines-center":
+            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))]
-        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":
+            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))]
-        elif pattern == "3-lines-bottom":
+            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 default")
-            positions = [(w // 2, int(h * 0.50))]
+            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}")
 
         # FIXED: Parse RGBA string from Gradio ColorPicker
@@ -224,74 +237,73 @@ def add_text_to_image(img, pattern, line1, line2, line3, font_size, color, add_o
         
         print(f"Final color for drawing: {final_color}")
         
-        # Draw text
-        lines = [line1, line2, line3][:len(positions)]
-        print(f"Active lines: {lines}")
+        # Draw text - PROPERLY handle all lines
+        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(zip(positions, lines)):
-            if txt and txt.strip():
-                print(f"Drawing line {i+1}: '{txt}' at position ({x}, {y})")
+        for i, ((x, y), txt) in enumerate(active_lines):
+            print(f"Drawing line {i+1}: '{txt}' at position ({x}, {y})")
+            
+            # Optional outline/stroke
+            if add_outline:
+                stroke_width = max(1, font_size // 20)
+                print(f"Adding outline with stroke width: {stroke_width}")
                 
-                # 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:
+                # 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:
-                                    draw.text((x + dx, y + dy), txt, fill=(0, 0, 0), font=font, anchor="mm")
-                                except TypeError:
-                                    # Fallback for older PIL versions
-                                    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)
-                else:
-                    print("Skipping outline (disabled)")
-                
-                # Draw main text with the properly parsed color
+                                    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)
+            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})")
+            except TypeError:
                 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})")
-                except TypeError:
-                    # Fallback for older PIL versions
-                    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 color {final_color} at ({fallback_x}, {fallback_y})")
-                    except Exception as e:
-                        print(f"Fallback failed: {e}, trying basic draw")
-                        draw.text((x, y), txt, fill=final_color, font=font)
-                        print(f"SUCCESS: Basic text drawn with color {final_color} at ({x}, {y})")
-                except Exception as e:
-                    print(f"ERROR drawing main text with final_color: {e}")
-                    # Last resort - try with white
-                    try:
-                        draw.text((x, y), txt, fill=(255, 255, 255), font=font, anchor="mm")
-                        print(f"FALLBACK: Drew text in white")
-                    except Exception as e2:
-                        print(f"Even white text failed: {e2}")
-                
-                text_drawn = True
-                print(f"Completed drawing line {i+1}")
+                    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 color {final_color} 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})")
+            
+            text_drawn = True
+            print(f"Completed drawing line {i+1}")
 
         if not text_drawn:
-            print("No text was 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"Text added! Color: {original_color} -> {final_color}, Outline: {add_outline}"
+        return image, f"✅ {len(active_lines)} lines added! Pattern: {detected_pattern}"
         
     except Exception as e:
         print(f"CRITICAL ERROR in add_text_to_image: {e}")
@@ -511,7 +523,7 @@ with gr.Blocks(title="AI Image Generator & Text Overlay") as demo:
                                 ("3-lines-center", "📋 3 Lines - Center (Full title)"),
                                 ("3-lines-bottom", "📋 3 Lines - Bottom (Credits style)")
                             ],
-                            value="2-lines-top",  # This now matches the first tuple value
+                            value="2-lines-top",
                             label="Layout Pattern"
                         )