Update app.py

app.py

@@ -75,15 +75,67 @@ def inpaintGen(
     return result, seed
 
 
+def add_border_and_mask(image, zoom_all=1.0, zoom_left=0, zoom_right=0, zoom_up=0, zoom_down=0, overlap=0.01):
+    """Adds a black border around the image with individual side control and mask overlap"""
+    orig_width, orig_height = image.size
+
+    # Calculate padding for each side (in pixels)
+    left_pad = int(orig_width * zoom_left)
+    right_pad = int(orig_width * zoom_right)
+    top_pad = int(orig_height * zoom_up)
+    bottom_pad = int(orig_height * zoom_down)
+
+    # Calculate overlap in pixels
+    overlap_left = int(orig_width * overlap)
+    overlap_right = int(orig_width * overlap)
+    overlap_top = int(orig_height * overlap)
+    overlap_bottom = int(orig_height * overlap)
+
+    # If using the all-sides zoom, add it to each side
+    if zoom_all > 1.0:
+        extra_each_side = (zoom_all - 1.0) / 2
+        left_pad += int(orig_width * extra_each_side)
+        right_pad += int(orig_width * extra_each_side)
+        top_pad += int(orig_height * extra_each_side)
+        bottom_pad += int(orig_height * extra_each_side)
+
+    # Calculate new dimensions (ensure they're multiples of 32)
+    new_width = 32 * round((orig_width + left_pad + right_pad) / 32)
+    new_height = 32 * round((orig_height + top_pad + bottom_pad) / 32)
+
+    # Create new image with black border
+    bordered_image = Image.new("RGB", (new_width, new_height), (0, 0, 0))
+    # Paste original image in position
+    paste_x = left_pad
+    paste_y = top_pad
+    bordered_image.paste(image, (paste_x, paste_y))
+
+    # Create mask (white where the border is, black where the original image was)
+    mask = Image.new("L", (new_width, new_height), 255)  # White background
+    # Paste black rectangle with overlap adjustment
+    mask.paste(
+        0,
+        (
+            paste_x + overlap_left,  # Left edge moves right
+            paste_y + overlap_top,  # Top edge moves down
+            paste_x + orig_width - overlap_right,  # Right edge moves left
+            paste_y + orig_height - overlap_bottom,  # Bottom edge moves up
+        ),
+    )
+
+    return bordered_image, mask
+
 
 @spaces.GPU()
 def outpaintGen(
     img,
     outpaint_prompt: str,
-    overlap_top: int,
-    overlap_right: int,
-    overlap_bottom: int,
-    overlap_left: int,
+    overlap: float,
+    zoom_all: float,
+    zoom_left: float,
+    zoom_right: float,
+    zoom_up: float,
+    zoom_down: float,
     op_guidance: float,
     op_num_steps: int,
     op_seed: int,
@@ -91,43 +143,18 @@ def outpaintGen(
 ):
     image = Image.open(img)
 
-    # Convert input to PIL Image if it's a numpy array
-    if isinstance(image, np.ndarray):
-        image = Image.fromarray(image)
+    new_image, mask_image = add_border_and_mask(
+            image,
+            zoom_all=zoom_all,
+            zoom_left=zoom_left,
+            zoom_right=zoom_right,
+            zoom_up=zoom_up,
+            zoom_down=zoom_down,
+            overlap=overlap,
+    )
 
-    # Get original dimensions
-    original_width, original_height = image.size
+    width, height = new_image.size
     
-    # Calculate new dimensions
-    new_width = original_width + overlap_left + overlap_right
-    new_height = original_height + overlap_top + overlap_bottom
-
-    # Create new blank mask image (black background)
-    mask_image = Image.new('RGB', (new_width, new_height), color='black')
-
-    # Create white rectangle for original image area
-    white_area = Image.new('RGB', (original_width, original_height), color='white')
-
-    # Paste white rectangle at the appropriate position
-    mask_image.paste(white_area, (overlap_left, overlap_top))
-
-    # Create a new image with the same size as the original image
-    new_image = Image.new('RGB', (new_width, new_height), color='black')
-
-    # Paste the original image onto the new image
-    new_image.paste(image, (overlap_left, overlap_top))
-
-    # Convert to grayscale
-    mask_image = mask_image.convert('L')
-    mask_image = Image.eval(mask_image, lambda x: 255 - x)
-    
-    fix_width = (new_width // 16) * 16
-    fix_height = (new_height // 16) * 16
-        
-    # If the image size is not already divisible by 16, resize it
-    # if new_width != fix_width or new_height != fix_height:
-    #     mask_image = mask_image.resize((fix_width, fix_height), Image.LANCZOS)
-
     if op_randomize_seed:
         op_seed = random.randint(0, MAX_SEED)
     generator = torch.Generator("cpu").manual_seed(op_seed)
@@ -136,8 +163,8 @@ def outpaintGen(
         prompt=outpaint_prompt,
         image=new_image,
         mask_image=mask_image,
-        width=fix_width,
-        height=fix_height,
+        width=width,
+        height=height,
         num_inference_steps=op_num_steps,
         generator=generator,
         guidance_scale=op_guidance,
@@ -198,11 +225,14 @@ with gr.Blocks(theme="ocean", title="Flux.1 Fill dev", css=CSS) as demo:
                     outpaint_clearBtn = gr.ClearButton([img, outpaint_prompt], value="Clear")
             image_exp = gr.Image(type="pil", label="Output", height=960)
         with gr.Accordion("Advanced ⚙️", open=False):
+            overlap = gr.Slider(label="Overlap", minimum=0.01, maximum=0.25, value=0.01, step=0.01)
+            zoom_all = gr.Slider(label="Zoom Out Amount (All Sides)", minimum=1.0, maximum=3.0, value=1.0, step=0.1)
+            with gr.Row():
+                zoom_left = gr.Slider(label="Left", minimum=0.0, maximum=1.0, value=0.0, step=0.1)
+                zoom_right = gr.Slider(label="Right", minimum=0.0, maximum=1.0, value=0.0, step=0.1)
             with gr.Row():
-                overlap_top = gr.Number(label="Top", value=64, precision=0)
-                overlap_right = gr.Number(label="Right", value=64, precision=0)
-                overlap_bottom = gr.Number(label="Bottom", value=64, precision=0)
-                overlap_left = gr.Number(label="Left", value=64, precision=0)
+                zoom_up = gr.Slider(label="Up", minimum=0.0, maximum=1.0, value=0.0, step=0.1)
+                zoom_down = gr.Slider(label="Down", minimum=0.0, maximum=1.0, value=0.0, step=0.1)
             op_guidance = gr.Slider(label="Guidance scale", minimum=1, maximum=50, value=30.0, step=0.1)
             op_num_steps = gr.Slider(label="Steps", minimum=1, maximum=50, value=20, step=1)
             op_seed = gr.Number(label="Seed", value=42, precision=0)
@@ -217,10 +247,12 @@ with gr.Blocks(theme="ocean", title="Flux.1 Fill dev", css=CSS) as demo:
             inputs = [
                 img,
                 outpaint_prompt,
-                overlap_top,
-                overlap_right,
-                overlap_bottom,
-                overlap_left,
+                overlap,
+                zoom_all,
+                zoom_left,
+                zoom_right,
+                zoom_up,
+                zoom_down,
                 op_guidance,
                 op_num_steps,
                 op_seed,