Upload 2 files

app.py

@@ -11,102 +11,113 @@ from diffusers import StableDiffusionInpaintPipeline
 from transformers import BlipProcessor, BlipForConditionalGeneration
 from modelscope.pipelines import pipeline
 from modelscope.utils.constant import Tasks
+
 import torchvision.transforms.functional as F
 sys.modules["torchvision.transforms.functional_tensor"] = F
 
 from basicsr.archs.rrdbnet_arch import RRDBNet
 from realesrgan import RealESRGANer
 
-# LOAD MODELS AT STARTUP
-# ── Real-ESRGAN ──────────────────────────────────────────────
-print("Downloading Real-ESRGAN weights...")
 
-weights_dir = "weights"
+# ================================================================
+# LOAD REAL-ESRGAN
+# ================================================================
+print("Setting up Real-ESRGAN...")
+
+weights_dir  = "weights"
 os.makedirs(weights_dir, exist_ok=True)
 weights_path = f"{weights_dir}/RealESRGAN_x4plus.pth"
+
 if not os.path.exists(weights_path):
     url = "https://github.com/xinntao/Real-ESRGAN/releases/download/v0.1.0/RealESRGAN_x4plus.pth"
     urllib.request.urlretrieve(url, weights_path)
     print("Weights downloaded.")
 
 esrgan_model = RRDBNet(
-    num_in_ch=3,
-    num_out_ch=3,
-    num_feat=64,
-    num_block=23,
-    num_grow_ch=32,
-    scale=4
+    num_in_ch=3, num_out_ch=3, num_feat=64,
+    num_block=23, num_grow_ch=32, scale=4
 )
 
 enhancer = RealESRGANer(
-    scale=4,
-    model_path=weights_path,
-    model=esrgan_model,
-    tile=512,
-    tile_pad=10,
-    pre_pad=0,
-    half=True,
+    scale=4, model_path=weights_path, model=esrgan_model,
+    tile=512, tile_pad=10, pre_pad=0, half=True,
 )
 print("Real-ESRGAN ready.")
 
-# ── SD Inpainting ────────────────────────────────────────────
-print("Loading SD Inpainting...")
+
+# ================================================================
+# LOAD SD2 INPAINTING
+# ================================================================
+print("Loading SD2 Inpainting...")
 
 inpaint = StableDiffusionInpaintPipeline.from_pretrained(
     "stabilityai/stable-diffusion-2-inpainting",
     torch_dtype=torch.float16,
-    variant= "fp16"
+    variant="fp16",
 )
-print("SD Inpainting ready.")
+# No .to("cuda") — ZeroGPU rule: only move inside @spaces.GPU functions
+print("SD2 Inpainting ready.")
+
+
+# ================================================================
+# LOAD DDCOLOR
+# ================================================================
+print("Loading DDColor...")
 
-# COLORING
 colorizer = pipeline(
     Tasks.image_colorization,
     model="damo/cv_ddcolor_image-colorization"
-    # DDColor = dedicated colorization model
-    # Trained specifically to add color without changing structure
 )
+print("DDColor ready.")
 
-print("Colorizer ready.")
 
-
-#  BLIP 
+# ================================================================
+# LOAD BLIP
+# ================================================================
 print("Loading BLIP...")
 
-blip_processor = BlipProcessor.from_pretrained(
-    "Salesforce/blip-image-captioning-base"
-)
+blip_processor = BlipProcessor.from_pretrained("Salesforce/blip-image-captioning-base")
 blip_model = BlipForConditionalGeneration.from_pretrained(
     "Salesforce/blip-image-captioning-base",
     torch_dtype=torch.float16,
 )
-# Same — no .to("cuda") at load time for ZeroGPU
 print("All models loaded.")
 
 
+# ================================================================
 # HELPER FUNCTIONS
+# ================================================================
+
 def is_greyscale(image):
-    rgb = image.convert("RGB")
+    # Returns True if image is effectively black and white
+    rgb     = image.convert("RGB")
     r, g, b = rgb.split()
-    r_arr = np.array(r, dtype=float)
-    g_arr = np.array(g, dtype=float)
-    b_arr = np.array(b, dtype=float)
+    r_arr   = np.array(r, dtype=float)
+    g_arr   = np.array(g, dtype=float)
+    b_arr   = np.array(b, dtype=float)
     diff_rg = np.mean(np.abs(r_arr - g_arr))
     diff_rb = np.mean(np.abs(r_arr - b_arr))
-    return (diff_rg < 10 and diff_rb < 10)
+    return diff_rg < 10 and diff_rb < 10
+
 
 def get_caption(image):
+    # BUG 3 FIX: single definition with blip_model.to("cuda")
+    # Previous code defined get_caption twice — Python used the last
+    # definition which was missing .to("cuda") causing cuda errors
     blip_model.to("cuda")
-    inputs = blip_processor(
-        image.convert("RGB"),
-        return_tensors="pt"
+    inputs  = blip_processor(
+        image.convert("RGB"), return_tensors="pt"
     ).to("cuda", torch.float16)
-    # Inside @spaces.GPU function, cuda is available
-    output = blip_model.generate(**inputs, max_new_tokens=60)
+    output  = blip_model.generate(**inputs, max_new_tokens=60)
     caption = blip_processor.decode(output[0], skip_special_tokens=True)
     return caption
 
-def build_prompt(caption, image): #for outpaint
+
+def build_outpaint_prompt(caption, image):
+    # BUG 4+5 FIX: single function, renamed from build_prompt
+    # Previous code defined build_prompt twice with different signatures
+    # Python used the last (one-arg) version, silently losing B&W detection
+    # Renamed to build_outpaint_prompt — no ambiguity possible
     bw = is_greyscale(image)
     style_hint = (
         "black and white photography, monochrome, greyscale, "
@@ -117,135 +128,123 @@ def build_prompt(caption, image): #for outpaint
     return (
         f"seamless natural continuation of scene, {caption}, "
         f"{style_hint}, extending background only, "
-        f"same atmosphere, high quality"
+        f"same atmosphere, high quality, no new subjects"
     )
 
 
+# ================================================================
+# ENHANCEMENT
+# ================================================================
 
 @spaces.GPU
 def enhance_image(image, scale_factor):
     if image is None:
         raise gr.Error("Please upload an image first.")
 
-    # Move models to GPU — happens inside the decorated function
-    # because GPU is only available here
     enhancer.device = torch.device("cuda")
     enhancer.half   = True
 
     image_array = np.array(image)
     image_array = image_array[:, :, :3]
-    outscale    = 4 if scale_factor == "4x" else 2
+    # Keep only RGB — drop alpha channel if RGBA (transparent PNG)
+
+    outscale = 4 if scale_factor == "4x" else 2
 
     try:
         output_array, _ = enhancer.enhance(image_array, outscale=outscale)
     except RuntimeError as e:
         raise gr.Error(f"Enhancement failed: {e}. Try a smaller image.")
 
-    output_rgb   = output_array[:, :, ::-1]
-    output_image = Image.fromarray(output_rgb)
+    output_image = Image.fromarray(output_array)
+    # Real-ESRGAN returns RGB — no channel flip needed
+
+    return (
+        output_image,
+        f"Original: {image.width}x{image.height} -> "
+        f"Enhanced: {output_image.width}x{output_image.height}"
+    )
 
-    original_size = f"{image.width}×{image.height}"
-    new_size      = f"{output_image.width}×{output_image.height}"
 
-    return output_image, f"Original: {original_size} → Enhanced: {new_size}"
+# ================================================================
+# COLORIZATION
+# ================================================================
 
 @spaces.GPU
 def colour_image(image, strength):
-    
-    if Image is None:
-        raise gr.Error("Please Upload the Image")
-
-    # Convert PIL to numpy RGB
-    img_array = image.convert("RGB")
-    # Resize so longest side = 512
-    # DDColor works best at this resolution
+    # BUG 1 FIX: was "if Image is None" (capital I = PIL class, never None)
+    if image is None:
+        raise gr.Error("Please upload an image first.")
+
+    image = image.convert("RGB")
+    # BUG 3 FIX: removed dead variable img_array that was assigned
+    # before resize and never used
+
     target = 512
     ratio  = min(target / image.width, target / image.height)
-    w      = int(image.width  * ratio)
-    h      = int(image.height * ratio)
-    image  = image.resize((w, h), Image.LANCZOS)
-    # LANCZOS = high quality resampling, preserves sharp edges
-    # DDColor expects BGR (OpenCV format)
-    # Convert PIL → numpy BGR for DDColor
+    image  = image.resize(
+        (int(image.width * ratio), int(image.height * ratio)),
+        Image.LANCZOS
+    )
+
+    # Convert PIL RGB -> numpy BGR for DDColor
     img_rgb = np.array(image)
-    # np.array(PIL) = numpy array shape (h, w, 3) in RGB
     img_bgr = img_rgb[:, :, ::-1]
+    # [:,:,::-1] reverses channel order: RGB -> BGR
 
-    #run colorizer
-    result= colorizer(img_bgr)
-    output_bgr= result["output_img"]
+    result     = colorizer(img_bgr)
+    output_bgr = result["output_img"]
+    # output_bgr = colorized BGR numpy array, same size as input
 
-    # Convert BGR → RGB for PIL
     output_rgb = output_bgr[:, :, ::-1]
+    # Reverse back: BGR -> RGB for PIL
 
-    # Apply strength blending
     if strength < 1.0:
-        grey    = np.array(image.convert("L"))
-        # convert("L") = convert to greyscale (single channel)
+        grey     = np.array(image.convert("L"))
         grey_3ch = np.stack([grey, grey, grey], axis=-1)
-        # stack same channel 3 times → (h, w, 3) array
-        # needed to match output_rgb shape for blending
+        # Stack single greyscale channel 3x to match (h,w,3) shape
         output_rgb = (
-            strength * output_rgb.astype(float) +
+            strength       * output_rgb.astype(float) +
             (1 - strength) * grey_3ch.astype(float)
         ).astype(np.uint8)
-        # Linear blend: weighted average of colored and grey
-        # .astype(np.uint8) = convert back to 0-255 integers
-        return Image.fromarray(output_rgb)
+        # Linear blend: strength=0.5 -> 50% color + 50% grey
 
+    # BUG 2 FIX: return is now OUTSIDE the if block
+    # Previous code returned inside "if strength < 1.0" only
+    # At strength=1.0 (slider max), function returned None -> crash
+    return Image.fromarray(output_rgb)
 
-def get_caption(image):
-    inputs  = blip_processor(image.convert("RGB"), return_tensors="pt").to("cuda", torch.float16)
-    output  = blip_model.generate(**inputs, max_new_tokens=60)
-    caption = blip_processor.decode(output[0], skip_special_tokens=True)
-    return caption
-
-
-def build_prompt(caption):
-    return (
-        f"seamless continuation of a scene with {caption}, "
-        f"same exact lighting, same exact style, "
-        f"same background, extending the existing scene naturally, "
-        f"no new objects, no new subjects, only environment continuation"
-    )
 
+# ================================================================
+# OUTPAINTING CORE
+# ================================================================
 
 def extend_one_side(image, direction, pixels, prompt, negative_prompt):
-    # CORE LOGIC — extends one side by a SMALL number of pixels
-    # Called multiple times in small steps instead of one big jump
-    # Small steps = SD always has lots of context = coherent output
-    
-    from PIL import ImageDraw
-
-    orig_w  = image.width
-    orig_h  = image.height
+    # Extends image by 'pixels' in 'direction'
+    # Called in 64px steps — small steps give SD max context
 
-    new_w   = orig_w
-    new_h   = orig_h
+    orig_w = image.width
+    orig_h = image.height
+    new_w  = orig_w
+    new_h  = orig_h
     paste_x = 0
     paste_y = 0
 
     if direction == "left":
         new_w   = orig_w + pixels
         paste_x = pixels
-
     elif direction == "right":
         new_w   = orig_w + pixels
-        paste_x = 0
-
     elif direction == "top":
         new_h   = orig_h + pixels
         paste_y = pixels
-
     elif direction == "bottom":
         new_h   = orig_h + pixels
-        paste_y = 0
 
-    # Round to multiple of 8 — SD requirement
+    # Round to multiple of 8 — SD UNet requirement
     new_w = (new_w // 8) * 8
     new_h = (new_h // 8) * 8
 
-    # Recalculate after rounding
+    # Recalculate pixels and paste positions after rounding
     if direction in ["left", "right"]:
         pixels = new_w - orig_w
     else:
@@ -256,259 +255,204 @@ def extend_one_side(image, direction, pixels, prompt, negative_prompt):
     if direction == "top":
         paste_y = pixels
 
-    # Build black canvas and paste original into it
+    # Black canvas with original pasted at correct position
     canvas = Image.new("RGB", (new_w, new_h), (0, 0, 0))
     canvas.paste(image, (paste_x, paste_y))
 
-    # ── Build mask ────────────────────────────────────────────
+    # Mask: white=generate, black=keep original
     mask = Image.new("L", (new_w, new_h), 255)
-    # All white = generate everywhere
     draw = ImageDraw.Draw(mask)
+    # BUG 6 FIX: removed redundant "from PIL import ImageDraw" inside function
+    # Already imported at top of file
 
     feather = 30
-    # This ensures the black region doesn't touch the very edge of original
-    # leaving a thin white strip that GaussianBlur will turn into a gradient
-
+    # 30px margin gives GaussianBlur room to create soft gradient
 
     if direction == "left":
-        draw.rectangle([
-            paste_x + feather,  feather,
-            new_w   - feather,  new_h - feather
-        ], fill=0)
-
+        draw.rectangle([paste_x + feather, feather, new_w - feather, new_h - feather], fill=0)
     elif direction == "right":
-        draw.rectangle([
-            feather, feather,
-            orig_w  - feather,  new_h - feather
-        ], fill=0)
-
+        draw.rectangle([feather, feather, orig_w - feather, new_h - feather], fill=0)
     elif direction == "top":
-        draw.rectangle([
-            feather,            paste_y + feather,
-            new_w   - feather,  new_h   - feather
-        ], fill=0)
-
+        draw.rectangle([feather, paste_y + feather, new_w - feather, new_h - feather], fill=0)
     elif direction == "bottom":
-        draw.rectangle([
-            feather,            feather,
-            new_w   - feather,  orig_h  - feather
-        ], fill=0)
+        draw.rectangle([feather, feather, new_w - feather, orig_h - feather], fill=0)
 
-    
-    #Apply GaussianBlur to the mask AFTER drawing
-    # This is what creates REAL feathering — a soft gradient at the boundary
-    mask= mask.filter(ImageFilter.GaussianBlur(radius=30))
+    # GaussianBlur creates real feathering — soft gradient at boundary
+    # Hard edge = visible seam. Soft gradient = seamless blend.
+    mask = mask.filter(ImageFilter.GaussianBlur(radius=30))
 
-    
+    # SD2 native resolution = 768x768
     sd_size   = 768
     canvas_sd = canvas.resize((sd_size, sd_size), Image.LANCZOS)
     mask_sd   = mask.resize((sd_size, sd_size), Image.LANCZOS)
-    # LANCZOS = high quality downsampling, preserves sharp details
+    # LANCZOS preserves soft gradient (NEAREST would destroy it)
 
     result = inpaint(
-        prompt              = prompt,
-        image               = canvas_sd,
-        mask_image          = mask_sd,
-        height              = sd_size,
-        width               = sd_size,
-        num_inference_steps = 40,
-        guidance_scale      = 7.0,
-        negative_prompt     = negative_prompt,
+        prompt=prompt, image=canvas_sd, mask_image=mask_sd,
+        height=sd_size, width=sd_size,
+        num_inference_steps=40, guidance_scale=7.0,
+        negative_prompt=negative_prompt,
     )
 
-    generated_512 = result.images[0]
-
-    generated_full = generated_512.resize((new_w, new_h), Image.LANCZOS)
+    generated_full = result.images[0].resize((new_w, new_h), Image.LANCZOS)
+    # No hard paste — feathered mask handles boundary softly
     return generated_full
 
+
+# ================================================================
+# OUTPAINTING MAIN
+# ================================================================
+
 @spaces.GPU
 def outpaint_image(image, direction, extend_percent, custom_prompt, progress=gr.Progress()):
 
     if image is None:
         raise gr.Error("Please upload an image first.")
+
     inpaint.to("cuda")
     blip_model.to("cuda")
+    # Move to GPU inside @spaces.GPU — ZeroGPU has allocated GPU here
 
-    # Resize input to max 512 on longest side
     max_side = 512
     ratio    = min(max_side / image.width, max_side / image.height)
-    
-    new_size = (int(image.width * ratio), int(image.height * ratio))
-    image    = image.resize(new_size, Image.LANCZOS)
+    image    = image.resize(
+        (int(image.width * ratio), int(image.height * ratio)),
+        Image.LANCZOS
+    )
 
     progress(0.05, desc="Analyzing image with BLIP...")
 
-    if custom_prompt.strip():
-        blip_caption = custom_prompt.strip()
-    else:
-        blip_caption = get_caption(image)
+    blip_caption = custom_prompt.strip() if custom_prompt.strip() else get_caption(image)
 
-    prompt = build_prompt(blip_caption)
+    # BUG 5 FIX: call build_outpaint_prompt with both args
+    # Previous code called build_prompt(caption) — one arg, wrong function
+    # Lost B&W detection entirely for all greyscale images
+    prompt = build_outpaint_prompt(blip_caption, image)
 
-    negative_prompt = (
+    base_negative = (
         "blurry, bad quality, watermark, text, "
         "new person, new face, new subject, extra people, "
-        "colorful, vibrant colors, color photography, "
         "duplicate, tiled, repeated pattern, border, frame, "
         "seam, visible edge, abrupt change, inconsistent, "
         "distorted, unnatural, different style, different era"
     )
+    negative_prompt = (
+        base_negative + ", colorful, vibrant colors, color photography"
+        if is_greyscale(image) else base_negative
+    )
+    # B&W images get extra negative terms to prevent SD adding color
 
-    # ── KEY CHANGE: small fixed step size, multiple passes ────
     STEP_PX = 64
-    # Add only 64 pixels per pass instead of the full extension at once
-    # 64px out of a 512px image = 12.5% of canvas = SD has 87.5% context
-    # Compare to before: 35% extension = SD only had 65% context
-    # More context = SD understands the scene = coherent generation
-
-    # Calculate total pixels needed per direction
-    extend   = extend_percent / 100.0
-    h_total  = int(image.width  * extend)
-    # Total horizontal pixels to add on each side
-    v_total  = int(image.height * extend)
-    # Total vertical pixels to add on each side
+    extend  = extend_percent / 100.0
+    h_total = int(image.width  * extend)
+    v_total = int(image.height * extend)
 
     def make_passes(side, total_px):
-        # Break total_px into multiple STEP_PX passes
-        # Example: total=180px, STEP_PX=64 → passes of [64, 64, 52]
-        passes = []
-        remaining = total_px
+        passes, remaining = [], total_px
         while remaining > 0:
             step = min(STEP_PX, remaining)
-            # min() = don't overshoot — last step may be smaller
             passes.append((side, step))
             remaining -= step
         return passes
-        # Returns list of (direction, pixels) tuples
-        # Each tuple = one call to extend_one_side
 
-    # Build full pass list based on chosen direction
     if direction == "Horizontal":
         passes = make_passes("right", h_total) + make_passes("left", h_total)
-        # Extend right in small steps, then left in small steps
-
     elif direction == "Vertical":
         passes = make_passes("bottom", v_total) + make_passes("top", v_total)
-        # Bottom first (more grounded content), then top
-
     else:
-        # Both — all four sides in small steps
         passes = (
-            make_passes("bottom", v_total) +
-            make_passes("top",    v_total) +
-            make_passes("right",  h_total) +
-            make_passes("left",   h_total)
+            make_passes("bottom", v_total) + make_passes("top",   v_total) +
+            make_passes("right",  h_total) + make_passes("left",  h_total)
         )
 
     total_passes  = len(passes)
     current_image = image
 
     for i, (side, px) in enumerate(passes):
-        progress_val = 0.1 + 0.85 * (i / total_passes)
-        progress(progress_val, desc=f"Pass {i+1}/{total_passes} — extending {side} by {px}px")
-
-        current_image = extend_one_side(
-            current_image,
-            side,
-            px,
-            prompt,
-            negative_prompt
+        progress(
+            0.1 + 0.85 * (i / total_passes),
+            desc=f"Pass {i+1}/{total_passes} — extending {side} by {px}px"
         )
-        # Each pass returns a slightly larger image
-        # Next pass uses that as input — builds on previous result
+        current_image = extend_one_side(current_image, side, px, prompt, negative_prompt)
 
     progress(1.0, desc="Done!")
 
-    return (
-        current_image,
-        f"BLIP caption:\n{blip_caption}\n\nFull prompt:\n{prompt}"
-    )
+    bw_note = " [B&W detected]" if is_greyscale(image) else ""
+    return current_image, f"Caption{bw_note}:\n{blip_caption}\n\nPrompt:\n{prompt}"
 
+
+# ================================================================
 # GRADIO UI
-with gr.Blocks(title="CanvasAI — Enhance & Outpaint") as demo:
+# ================================================================
+
+with gr.Blocks(title="CanvasAI") as demo:
 
-    gr.Markdown("#  CanvasAI")
+    gr.Markdown("# CanvasAI")
     gr.Markdown(
-        "**Enhance** any image with Real-ESRGAN super resolution, "
-        "or **Outpaint** to extend the scene in any direction using AI."
+        "**Enhance** with Real-ESRGAN  |  "
+        "**Colorize** B&W photos with DDColor  |  "
+        "**Outpaint** to extend any scene with SD2"
     )
 
     with gr.Tabs():
 
-        with gr.Tab(" Enhance"):
+        with gr.Tab("Enhance"):
             gr.Markdown("Upscale and sharpen any image 2x or 4x using Real-ESRGAN.")
             with gr.Row():
                 with gr.Column():
                     enh_input = gr.Image(label="Upload Image", type="pil")
                     enh_scale = gr.Dropdown(
-                        choices=["2x", "4x"],
-                        value="4x",
-                        label="Upscale Factor"
+                        choices=["2x", "4x"], value="4x", label="Upscale Factor",
+                        info="4x recommended. Use 2x for very large inputs."
                     )
                     enh_btn = gr.Button("Enhance", variant="primary")
                 with gr.Column():
                     enh_output = gr.Image(label="Result", type="pil", interactive=False)
                     enh_info   = gr.Textbox(label="Size Info", interactive=False)
 
-            enh_btn.click(
-                fn=enhance_image,
-                inputs=[enh_input, enh_scale],
-                outputs=[enh_output, enh_info]
-            )
+            enh_btn.click(fn=enhance_image, inputs=[enh_input, enh_scale], outputs=[enh_output, enh_info])
 
-        with gr.Tab("Colourize"):
-            gr.Markdown("Upload a black and white image. "
-        "AI adds natural, realistic colours while preserving the original structure.")
+        with gr.Tab("Colorize"):
+            gr.Markdown(
+                "Upload a black and white image. "
+                "DDColor adds natural, realistic colors while preserving the original structure."
+            )
             with gr.Row():
                 with gr.Column():
-                    col_input= gr.Image(
-                        label="Upload Image",
-                        type="pil",
-                    )
-                    col_strength= gr.Slider(
-                        minimum= 0.3,
-                        maximum= 0.7,
-                        value= 0.5,
-                        step= 0.05,
-                        label= "Colorization Strength",
-                        info= "Low = subtle tint, stays close to original. High = vivid colours."
-                    )
-
-                    col_btn= gr.Button(
-                        "Colorize", variant="primary"
+                    col_input    = gr.Image(label="Upload B&W Image", type="pil")
+                    col_strength = gr.Slider(
+                        minimum=0.5, maximum=1.0, value=0.9, step=0.05,
+                        label="Color Strength",
+                        # BUG 10 FIX: maximum changed from 0.7 to 1.0
+                        # User can now reach full DDColor output at 1.0
+                        info="0.5 = subtle tint. 1.0 = full vivid DDColor output."
                     )
+                    col_btn = gr.Button("Colorize", variant="primary")
                 with gr.Column():
-                    col_output= gr.Image(label="Colorized Result", type="pil", interactive=False)
-            col_btn.click(
-                fn= colour_image,
-                inputs= [col_input, col_strength],
-                outputs= [col_output]
-            )
+                    col_output = gr.Image(label="Colorized Result", type="pil", interactive=False)
+
+            col_btn.click(fn=colour_image, inputs=[col_input, col_strength], outputs=[col_output])
 
-        with gr.Tab(" Outpaint"):
+        with gr.Tab("Outpaint"):
             gr.Markdown(
                 "Upload an image and extend it in any direction. "
                 "BLIP reads the scene automatically — no prompt needed."
             )
             with gr.Row():
                 with gr.Column():
-                    out_input = gr.Image(label="Upload Image", type="pil")
-                    out_dir   = gr.Radio(
-                        choices=["Horizontal", "Vertical", "Both"],
-                        value="Horizontal",
-                        label="Direction"
-                    )
-                    out_pct = gr.Slider(
-                        minimum=10, maximum=50,
-                        value=25, step=5,
-                        label="Extend by (%)"
+                    out_input  = gr.Image(label="Upload Image", type="pil")
+                    out_dir    = gr.Radio(
+                        choices=["Horizontal", "Vertical", "Both"], value="Horizontal",
+                        label="Extension Direction",
+                        info="Horizontal = left & right | Vertical = top & bottom | Both = all sides"
                     )
+                    out_pct    = gr.Slider(minimum=10, maximum=50, value=25, step=5, label="Extend by (%)")
                     out_prompt = gr.Textbox(
                         label="Custom Prompt (optional)",
-                        placeholder="Leave empty for auto-detection",
+                        placeholder="Leave empty — BLIP reads your image automatically",
                         lines=2
                     )
-                    out_btn = gr.Button("🔲 Outpaint", variant="primary")
+                    out_btn = gr.Button("Outpaint", variant="primary")
                 with gr.Column():
                     out_output  = gr.Image(label="Result", type="pil", interactive=False)
                     out_caption = gr.Textbox(label="Prompt Used", interactive=False, lines=4)
@@ -519,5 +463,4 @@ with gr.Blocks(title="CanvasAI — Enhance & Outpaint") as demo:
                 outputs=[out_output, out_caption]
             )
 
-#launch
 demo.launch()

requirements.txt

@@ -5,7 +5,10 @@ transformers
 accelerate
 Pillow
 numpy
+opencv-python
 basicsr
 facexlib
 gfpgan
-realesrgan@ git+https://github.com/xinntao/Real-ESRGAN.git
+realesrgan@ git+https://github.com/xinntao/Real-ESRGAN.git
+modelscope
+spaces