Update app.py

app.py

@@ -8,8 +8,8 @@ import textwrap
 
 # Function to remove background and place text behind person
 def text_behind_image(input_image, text, text_color, font_size, text_opacity):
-    if input_image is None:
-        return None
+    if input_image is None or text.strip() == "":
+        return input_image
     
     # Convert color hex to RGB
     try:
@@ -18,7 +18,7 @@ def text_behind_image(input_image, text, text_color, font_size, text_opacity):
         b = int(text_color[5:7], 16)
         text_color_rgb = (r, g, b)
     except:
-        text_color_rgb = (255, 255, 255)  # Default to white
+        text_color_rgb = (0, 0, 0)  # Default to black
     
     try:
         # Open the image
@@ -27,104 +27,97 @@ def text_behind_image(input_image, text, text_color, font_size, text_opacity):
         # Get dimensions
         width, height = img.size
         
-        # Create a new image with white background (this will be the canvas)
-        background = Image.new('RGBA', (width, height), (255, 255, 255, 255))
+        # First, remove background from the original image to get the person silhouette
+        try:
+            person_img = remove(img, model_name="u2net_human_seg")
+        except:
+            # Fallback to default model if human_seg not available
+            person_img = remove(img)
         
-        # Create a drawing context for the text
-        draw = ImageDraw.Draw(background)
+        # Create a new image with white background for the text
+        text_bg = Image.new('RGBA', (width, height), (255, 255, 255, 255))
+        draw = ImageDraw.Draw(text_bg)
         
-        # Determine font size (relative to image size)
-        font_size = int(min(width, height) * (font_size / 100))  # Convert percentage to actual size
-        if font_size < 10:  # Ensure font is at least 10 pixels
-            font_size = 10
+        # Prepare the text
+        text = text.strip().upper()
+        if not text:
+            text = "SAMPLE TEXT"
+            
+        # Set up the font
+        font_size = max(10, int(min(width, height) * (font_size / 100)))
         
-        # Try to load a nice font, fall back to default if not available
+        # Try several fonts
+        font = None
         try:
-            # Try different common fonts
             font_paths = [
                 "arial.ttf", 
                 "/usr/share/fonts/truetype/dejavu/DejaVuSans-Bold.ttf",
-                "/usr/share/fonts/truetype/liberation/LiberationSans-Bold.ttf"
+                "/usr/share/fonts/truetype/liberation/LiberationSans-Bold.ttf",
+                "/usr/share/fonts/truetype/freefont/FreeSansBold.ttf"
             ]
-            font = None
+            
             for font_path in font_paths:
                 try:
                     font = ImageFont.truetype(font_path, font_size)
                     break
                 except:
                     continue
-                    
-            if font is None:
-                font = ImageFont.load_default()
         except:
+            pass
+            
+        if font is None:
             font = ImageFont.load_default()
-        
-        # Prepare the text - make it ALL CAPS for better visual impact
-        text = text.upper()
-        
-        # Fill the entire background with repeating text pattern
-        # Word wrap the text to fit within the image width
-        margin = 20
-        max_chars = max(10, int(width / (font_size/2)) - 2*margin)
-        wrapper = textwrap.TextWrapper(width=max_chars)
-        word_list = wrapper.wrap(text)
-        
-        # If text is too short, repeat it to fill the background
-        if len(word_list) == 1 and len(text) < 10:
-            repeated_text = (text + " ") * 10
-            word_list = []
-            for i in range(0, height, font_size + 5):
-                word_list.append(repeated_text)
-        
-        # Calculate text block height
-        line_spacing = int(font_size * 1.2)
-        text_height = len(word_list) * line_spacing
-        
-        # Position text in the center
-        y_text = (height - text_height) // 2
-        
-        # Draw text with specified opacity
-        for line in word_list:
-            # Get line width
-            try:
-                line_width = font.getbbox(line)[2] - font.getbbox(line)[0]
-            except:
-                # Fallback method to estimate width
-                line_width = len(line) * (font_size // 2)
                 
-            # Center the line
-            x_text = (width - line_width) // 2
+        # For short text, create a repeating pattern across the entire image
+        if len(text) < 20:
+            repeated_text = (text + " ") * 20
+            line_height = int(font_size * 1.5)
             
-            # Draw text with specified opacity
-            text_color_with_opacity = text_color_rgb + (int(text_opacity * 255),)
-            draw.text((x_text, y_text), line, font=font, fill=text_color_with_opacity)
-            y_text += line_spacing
-        
-        # Ensure the text is very visible by drawing it multiple times with different Y positions
-        if len(word_list) < 5:
-            for offset in [-line_spacing*2, line_spacing*2]:
-                y_text = (height - text_height) // 2 + offset
-                for line in word_list:
-                    try:
-                        line_width = font.getbbox(line)[2] - font.getbbox(line)[0]
-                    except:
-                        line_width = len(line) * (font_size // 2)
-                    x_text = (width - line_width) // 2
-                    draw.text((x_text, y_text), line, font=font, fill=text_color_with_opacity)
-                    y_text += line_spacing
-        
-        # Remove background from the original image to get the person silhouette
-        # Use the u2net_human_seg model specifically for better human segmentation
-        try:
-            person_img = remove(img, model_name="u2net_human_seg")
-        except:
-            # Fallback to default model if human_seg not available
-            person_img = remove(img)
+            # Draw text in a grid pattern covering the entire image
+            for y in range(0, height, line_height):
+                # Offset each line for a more interesting pattern
+                offset = (y // line_height) % 20
+                line = repeated_text[offset:] + repeated_text[:offset]
+                
+                # Draw the text
+                draw.text((10, y), line, font=font, fill=text_color_rgb + (int(text_opacity * 255),))
+                
+        else:
+            # For longer text, do proper word wrapping
+            margin = 20
+            max_width = width - 2 * margin
+            
+            # Calculate approx chars per line (estimating 0.6 × font_size per char width)
+            chars_per_line = max(10, int(max_width / (font_size * 0.6)))
+            
+            # Word wrap
+            wrapper = textwrap.TextWrapper(width=chars_per_line)
+            lines = wrapper.wrap(text)
+            
+            # Calculate total text height
+            line_height = int(font_size * 1.5)
+            text_height = len(lines) * line_height
+            
+            # Calculate starting Y position (centered)
+            start_y = (height - text_height) // 2
+            
+            # Draw each line
+            for i, line in enumerate(lines):
+                # Estimate line width (better than using font.getbbox which can fail)
+                line_width = min(max_width, len(line) * int(font_size * 0.6))
+                
+                # Center the line
+                x = (width - line_width) // 2
+                y = start_y + (i * line_height)
+                
+                # Draw the text with opacity
+                draw.text((x, y), line, font=font, fill=text_color_rgb + (int(text_opacity * 255),))
         
-        # Composite the images: text in background, then person on top
-        final_image = Image.alpha_composite(background.convert('RGBA'), person_img.convert('RGBA'))
+        # Now combine the text background with the person
+        # The text goes behind the person, so we composite person on top of text
+        final_image = Image.alpha_composite(text_bg, person_img)
         
-        # Convert back to RGB for display
+        # Convert to RGB for display
         return np.array(final_image.convert('RGB'))
     
     except Exception as e:
@@ -142,7 +135,7 @@ with gr.Blocks(title="Text Behind Image") as demo:
             text_input = gr.Textbox(label="Text to place behind", placeholder="Enter text here...")
             
             with gr.Row():
-                text_color = gr.ColorPicker(label="Text Color", value="#FFFFFF")
+                text_color = gr.ColorPicker(label="Text Color", value="#000000")
                 font_size = gr.Slider(label="Font Size (%)", minimum=1, maximum=30, value=10, step=1)
                 text_opacity = gr.Slider(label="Text Opacity", minimum=0.1, maximum=1.0, value=0.8, step=0.1)