New version, extremely detailed, not blur, fine options (#2)

- New version, extremely detailed, not blur, fine options (3816ea0560103624979502ad90b13d4115aafedb)


Co-authored-by: Fabrice TIERCELIN <[email protected]>

app.py

@@ -1,307 +1,482 @@
-import cv2
-import numpy as np
-import torch
 import gradio as gr
+import numpy as np
+import time
+import math
 import random
-import spaces
-
-from diffusers import DPMSolverMultistepScheduler, StableDiffusionXLPipeline
-from diffusers.utils import load_image
-
-DESCRIPTION='''
-This uses code lifted almost verbatim from
-[Outpainting II - Differential Diffusion](https://huggingface.co/blog/OzzyGT/outpainting-differential-diffusion).  This only works well on blurry edges.
-'''
+import torch
 
-ARTICLE='''
-The [example image](https://commons.wikimedia.org/wiki/File:Coucang.jpg) is by Aprisonsan
-and licensed under CC-BY-SA 4.0 International.
-'''
+from diffusers import StableDiffusionXLInpaintPipeline
+from PIL import Image, ImageFilter
 
-xlp_kwargs = {
-    'custom_pipeline': 'pipeline_stable_diffusion_xl_differential_img2img'
-}
+max_64_bit_int = 2**63 - 1
 
 if torch.cuda.is_available():
-    device = 'cuda'
-    device_dtype = torch.float16
-    xlp_kwargs['variant'] = 'fp16'
+    device = "cuda"
+    floatType = torch.float16
+    variant = "fp16"
 else:
-    device = 'cpu'
-    device_dtype = torch.float32
-    DESCRIPTION+='''
-
-This Space appears to be running on a CPU; it will take hours to get results.  You may [duplicate this space](https://huggingface.co/spaces/clinteroni/outpainting-demo?duplicate=true) and pay for an upgraded runtime instead.
-    '''
-
-xlp_kwargs['torch_dtype'] = device_dtype
-
-
-def merge_images(original, new_image, offset, direction):
-    if direction in ["left", "right"]:
-        merged_image = np.zeros(
-            (original.shape[0], original.shape[1] + offset, 3), dtype=np.uint8)
-    elif direction in ["top", "bottom"]:
-        merged_image = np.zeros(
-            (original.shape[0] + offset, original.shape[1], 3), dtype=np.uint8)
-
-    if direction == "left":
-        merged_image[:, offset:] = original
-        merged_image[:, : new_image.shape[1]] = new_image
-    elif direction == "right":
-        merged_image[:, : original.shape[1]] = original
-        merged_image[:, original.shape[1] + offset -
-                     new_image.shape[1]: original.shape[1] + offset] = new_image
-    elif direction == "top":
-        merged_image[offset:, :] = original
-        merged_image[: new_image.shape[0], :] = new_image
-    elif direction == "bottom":
-        merged_image[: original.shape[0], :] = original
-        merged_image[original.shape[0] + offset - new_image.shape[0]:original.shape[0] + offset, :] = new_image
-
-    return merged_image
-
-
-def slice_image(image):
-    height, width, _ = image.shape
-    slice_size = min(width // 2, height // 3)
-
-    slices = []
-
-    for h in range(3):
-        for w in range(2):
-            left = w * slice_size
-            upper = h * slice_size
-            right = left + slice_size
-            lower = upper + slice_size
-
-            if w == 1 and right > width:
-                left -= right - width
-                right = width
-            if h == 2 and lower > height:
-                upper -= lower - height
-                lower = height
-
-            slice = image[upper:lower, left:right]
-            slices.append(slice)
-
-    return slices
-
-
-def process_image(
-    image,
-    fill_color=(0, 0, 0),
-    mask_offset=50,
-    blur_radius=500,
-    expand_pixels=256,
-    direction="left",
-    inpaint_mask_color=50,
-    max_size=1024,
-):
-    height, width = image.shape[:2]
-
-    new_height = height + \
-        (expand_pixels if direction in ["top", "bottom"] else 0)
-    new_width = width + \
-        (expand_pixels if direction in ["left", "right"] else 0)
-
-    if new_height > max_size:
-        # If so, crop the image from the opposite side
-        if direction == "top":
-            image = image[:max_size, :]
-        elif direction == "bottom":
-            image = image[new_height - max_size:, :]
-        new_height = max_size
-
-    if new_width > max_size:
-        # If so, crop the image from the opposite side
-        if direction == "left":
-            image = image[:, :max_size]
-        elif direction == "right":
-            image = image[:, new_width - max_size:]
-        new_width = max_size
-
-    height, width = image.shape[:2]
-
-    new_image = np.full((new_height, new_width, 3), fill_color, dtype=np.uint8)
-    mask = np.full_like(new_image, 255, dtype=np.uint8)
-    inpaint_mask = np.full_like(new_image, 0, dtype=np.uint8)
-
-    mask = cv2.cvtColor(mask, cv2.COLOR_BGR2GRAY)
-    inpaint_mask = cv2.cvtColor(inpaint_mask, cv2.COLOR_BGR2GRAY)
-
-    if direction == "left":
-        new_image[:, expand_pixels:] = image[:, : max_size - expand_pixels]
-        mask[:, : expand_pixels + mask_offset] = inpaint_mask_color
-        inpaint_mask[:, :expand_pixels] = 255
-    elif direction == "right":
-        new_image[:, :width] = image
-        mask[:, width - mask_offset:] = inpaint_mask_color
-        inpaint_mask[:, width:] = 255
-    elif direction == "top":
-        new_image[expand_pixels:, :] = image[: max_size - expand_pixels, :]
-        mask[: expand_pixels + mask_offset, :] = inpaint_mask_color
-        inpaint_mask[:expand_pixels, :] = 255
-    elif direction == "bottom":
-        new_image[:height, :] = image
-        mask[height - mask_offset:, :] = inpaint_mask_color
-        inpaint_mask[height:, :] = 255
-
-    # mask blur
-    if blur_radius % 2 == 0:
-        blur_radius += 1
-    mask = cv2.GaussianBlur(mask, (blur_radius, blur_radius), 0)
-
-    # telea inpaint
-    _, mask_np = cv2.threshold(
-        inpaint_mask, 128, 255, cv2.THRESH_BINARY | cv2.THRESH_OTSU)
-    inpaint = cv2.inpaint(new_image, mask_np, 3, cv2.INPAINT_TELEA)
-
-    # convert image to tensor
-    inpaint = cv2.cvtColor(inpaint, cv2.COLOR_BGR2RGB)
-    inpaint = torch.from_numpy(inpaint).permute(2, 0, 1).float()
-    inpaint = inpaint / 127.5 - 1
-    inpaint = inpaint.unsqueeze(0).to(device)
-
-    # convert mask to tensor
-    mask = torch.from_numpy(mask)
-    mask = mask.unsqueeze(0).float() / 255.0
-    mask = mask.to(device)
-
-    return inpaint, mask
-
-
-def image_resize(image, new_size=1024):
-    height, width = image.shape[:2]
-
-    aspect_ratio = width / height
-    new_width = new_size
-    new_height = new_size
-
-    if aspect_ratio != 1:
-        if width > height:
-            new_height = int(new_size / aspect_ratio)
-        else:
-            new_width = int(new_size * aspect_ratio)
+    device = "cpu"
+    floatType = torch.float32
+    variant = None
+
+pipe = StableDiffusionXLInpaintPipeline.from_pretrained("diffusers/stable-diffusion-xl-1.0-inpainting-0.1", torch_dtype = floatType, variant = variant)
+pipe = pipe.to(device)
+
+def update_seed(is_randomize_seed, seed):
+    if is_randomize_seed:
+        return random.randint(0, max_64_bit_int)
+    return seed
+
+def toggle_debug(is_debug_mode):
+    return [gr.update(visible = is_debug_mode)] * 3
+
+def noise_color(color, noise):
+    return color + random.randint(- noise, noise)
+
+def check(
+    input_image,
+    enlarge_top,
+    enlarge_right,
+    enlarge_bottom,
+    enlarge_left,
+    prompt,
+    negative_prompt,
+    smooth_border,
+    num_inference_steps,
+    guidance_scale,
+    image_guidance_scale,
+    strength,
+    denoising_steps,
+    is_randomize_seed,
+    seed,
+    debug_mode,
+    progress = gr.Progress()):
+    if input_image is None:
+        raise gr.Error("Please provide an image.")
+
+    if prompt is None or prompt == "":
+        raise gr.Error("Please provide a prompt input.")
+
+    if (not (enlarge_top is None)) and enlarge_top < 0:
+        raise gr.Error("Please provide positive top margin.")
+
+    if (not (enlarge_right is None)) and enlarge_right < 0:
+        raise gr.Error("Please provide positive right margin.")
+
+    if (not (enlarge_bottom is None)) and enlarge_bottom < 0:
+        raise gr.Error("Please provide positive bottom margin.")
+
+    if (not (enlarge_left is None)) and enlarge_left < 0:
+        raise gr.Error("Please provide positive left margin.")
+
+    if (
+        (enlarge_top is None or enlarge_top == 0)
+        and (enlarge_right is None or enlarge_right == 0)
+        and (enlarge_bottom is None or enlarge_bottom == 0)
+        and (enlarge_left is None or enlarge_left == 0)
+    ):
+        raise gr.Error("At least one border must be enlarged.")
+
+def uncrop(
+    input_image,
+    enlarge_top,
+    enlarge_right,
+    enlarge_bottom,
+    enlarge_left,
+    prompt,
+    negative_prompt,
+    smooth_border,
+    num_inference_steps,
+    guidance_scale,
+    image_guidance_scale,
+    strength,
+    denoising_steps,
+    is_randomize_seed,
+    seed,
+    debug_mode,
+    progress = gr.Progress()):
+    check(
+        input_image,
+        enlarge_top,
+        enlarge_right,
+        enlarge_bottom,
+        enlarge_left,
+        prompt,
+        negative_prompt,
+        smooth_border,
+        num_inference_steps,
+        guidance_scale,
+        image_guidance_scale,
+        strength,
+        denoising_steps,
+        is_randomize_seed,
+        seed,
+        debug_mode
+    )
+    start = time.time()
+    progress(0, desc = "Preparing data...")
+
+    if enlarge_top is None or enlarge_top == "":
+        enlarge_top = 0
+
+    if enlarge_right is None or enlarge_right == "":
+        enlarge_right = 0
+
+    if enlarge_bottom is None or enlarge_bottom == "":
+        enlarge_bottom = 0
+
+    if enlarge_left is None or enlarge_left == "":
+        enlarge_left = 0
+
+    if negative_prompt is None:
+        negative_prompt = ""
+
+    if smooth_border is None:
+        smooth_border = 0
+
+    if num_inference_steps is None:
+        num_inference_steps = 50
+
+    if guidance_scale is None:
+        guidance_scale = 7
+
+    if image_guidance_scale is None:
+        image_guidance_scale = 1.5
 
-    image = cv2.resize(image, (new_width, new_height),
-                       interpolation=cv2.INTER_LANCZOS4)
+    if strength is None:
+        strength = 0.99
 
-    return image
+    if denoising_steps is None:
+        denoising_steps = 1000
 
+    if seed is None:
+        seed = random.randint(0, max_64_bit_int)
 
-@spaces.GPU
-def outpaint(pil_image, direction='right', times_to_expand=4, guidance_scale=4.0, blur_radius=500):
-    if torch.cuda.is_available():
-        torch.cuda.empty_cache()
+    random.seed(seed)
+    torch.manual_seed(seed)
 
-    pipeline = StableDiffusionXLPipeline.from_pretrained(
-        "stabilityai/stable-diffusion-xl-base-1.0",
-        **xlp_kwargs
-    ).to(device)
-    pipeline.scheduler = DPMSolverMultistepScheduler.from_config(
-        pipeline.scheduler.config, use_karras_sigmas=True)
+    original_height, original_width, original_channel = np.array(input_image).shape
+    output_width = enlarge_left + original_width + enlarge_right
+    output_height = enlarge_top + original_height + enlarge_bottom
 
-    pipeline.load_ip_adapter(
-        "h94/IP-Adapter",
-        subfolder="sdxl_models",
-        weight_name=[
-            "ip-adapter-plus_sdxl_vit-h.safetensors",
+    # Enlarged image
+    enlarged_image = Image.new(mode = input_image.mode, size = (original_width, original_height), color = "black")
+    enlarged_image.paste(input_image, (0, 0))
+    enlarged_image = enlarged_image.resize((output_width, output_height))
+    enlarged_image = enlarged_image.filter(ImageFilter.BoxBlur(20))
+
+    enlarged_image.paste(input_image, (enlarge_left, enlarge_top))
+
+    horizontally_mirrored_input_image = input_image.transpose(Image.FLIP_LEFT_RIGHT).resize((original_width * 2, original_height))
+    enlarged_image.paste(horizontally_mirrored_input_image, (enlarge_left - (original_width * 2), enlarge_top))
+    enlarged_image.paste(horizontally_mirrored_input_image, (enlarge_left + original_width, enlarge_top))
+
+    vertically_mirrored_input_image = input_image.transpose(Image.FLIP_TOP_BOTTOM).resize((original_width, original_height * 2))
+    enlarged_image.paste(vertically_mirrored_input_image, (enlarge_left, enlarge_top - (original_height * 2)))
+    enlarged_image.paste(vertically_mirrored_input_image, (enlarge_left, enlarge_top + original_height))
+
+    returned_input_image = input_image.transpose(Image.ROTATE_180).resize((original_width * 2, original_height * 2))
+    enlarged_image.paste(returned_input_image, (enlarge_left - (original_width * 2), enlarge_top - (original_height * 2)))
+    enlarged_image.paste(returned_input_image, (enlarge_left - (original_width * 2), enlarge_top + original_height))
+    enlarged_image.paste(returned_input_image, (enlarge_left + original_width, enlarge_top - (original_height * 2)))
+    enlarged_image.paste(returned_input_image, (enlarge_left + original_width, enlarge_top + original_height))
+
+    enlarged_image = enlarged_image.filter(ImageFilter.BoxBlur(20))
+
+    # Noise image
+    noise_image = Image.new(mode = input_image.mode, size = (output_width, output_height), color = "black")
+    enlarged_pixels = enlarged_image.load()
+
+    for i in range(output_width):
+        for j in range(output_height):
+            enlarged_pixel = enlarged_pixels[i, j]
+            noise = min(max(enlarge_left - i, i - (enlarge_left + original_width), enlarge_top - j, j - (enlarge_top + original_height), 0), 255)
+            noise_image.putpixel((i, j), (noise_color(enlarged_pixel[0], noise), noise_color(enlarged_pixel[1], noise), noise_color(enlarged_pixel[2], noise), 255))
+
+    enlarged_image.paste(noise_image, (0, 0))
+    enlarged_image.paste(input_image, (enlarge_left, enlarge_top))
+
+    # Mask
+    mask_image = Image.new(mode = input_image.mode, size = (output_width, output_height), color = (255, 255, 255, 0))
+    black_mask = Image.new(mode = input_image.mode, size = (original_width - smooth_border, original_height - smooth_border), color = (0, 0, 0, 0))
+    mask_image.paste(black_mask, (enlarge_left + (smooth_border // 2), enlarge_top + (smooth_border // 2)))
+    mask_image = mask_image.filter(ImageFilter.BoxBlur((smooth_border // 2)))
+
+    # Limited to 1 million pixels
+    if 1024 * 1024 < output_width * output_height:
+        factor = ((1024 * 1024) / (output_width * output_height))**0.5
+        process_width = math.floor(output_width * factor)
+        process_height = math.floor(output_height * factor)
+
+        limitation = " Due to technical limitation, the image have been downscaled and then upscaled.";
+    else:
+        process_width = output_width
+        process_height = output_height
+
+        limitation = "";
+
+    # Width and height must be multiple of 8
+    if (process_width % 8) != 0 or (process_height % 8) != 0:
+        if ((process_width - (process_width % 8) + 8) * (process_height - (process_height % 8) + 8)) <= (1024 * 1024):
+            process_width = process_width - (process_width % 8) + 8
+            process_height = process_height - (process_height % 8) + 8
+        elif (process_height % 8) <= (process_width % 8) and ((process_width - (process_width % 8) + 8) * process_height) <= (1024 * 1024):
+            process_width = process_width - (process_width % 8) + 8
+            process_height = process_height - (process_height % 8)
+        elif (process_width % 8) <= (process_height % 8) and (process_width * (process_height - (process_height % 8) + 8)) <= (1024 * 1024):
+            process_width = process_width - (process_width % 8)
+            process_height = process_height - (process_height % 8) + 8
+        else:
+            process_width = process_width - (process_width % 8)
+            process_height = process_height - (process_height % 8)
+
+    progress(None, desc = "Processing...")
+
+    output_image = pipe(
+        seeds = [seed],
+        width = process_width,
+        height = process_height,
+        prompt = prompt,
+        negative_prompt = negative_prompt,
+        image = enlarged_image,
+        mask_image = mask_image,
+        num_inference_steps = num_inference_steps,
+        guidance_scale = guidance_scale,
+        image_guidance_scale = image_guidance_scale,
+        strength = strength,
+        denoising_steps = denoising_steps,
+        show_progress_bar = True
+    ).images[0]
+
+    if limitation != "":
+        output_image = output_image.resize((output_width, output_height))
+
+    if debug_mode == False:
+        input_image = None
+        enlarged_image = None
+        mask_image = None
+
+    end = time.time()
+    secondes = int(end - start)
+    minutes = math.floor(secondes / 60)
+    secondes = secondes - (minutes * 60)
+    hours = math.floor(minutes / 60)
+    minutes = minutes - (hours * 60)
+    return [
+        output_image,
+        ("Start again to get a different result. " if is_randomize_seed else "") + "The new image is " + str(output_width) + " pixels large and " + str(output_height) + " pixels high, so an image of " + f'{output_width * output_height:,}' + " pixels. The image has been generated in " + ((str(hours) + " h, ") if hours != 0 else "") + ((str(minutes) + " min, ") if hours != 0 or minutes != 0 else "") + str(secondes) + " sec." + limitation,
+        input_image,
+        enlarged_image,
+        mask_image
+    ]
+
+with gr.Blocks() as interface:
+    gr.HTML(
+        """
+        <h1 style="text-align: center;">Outpainting demo</h1>
+        <p style="text-align: center;">Enlarges the point of view of your image, freely, without account, without watermark, without installation, which can be downloaded</p>
+        <br/>
+        <br/>
+        ✨ Powered by <i>SDXL 1.0</i> artificial intellingence.
+        <br/>
+        💻 Your computer must <u>not</u> enter into standby mode.<br/>You can duplicate this space on a free account, it works on CPU and CUDA.<br/>
+        <a href='https://huggingface.co/spaces/clinteroni/outpainting-with-differential-diffusion-demo?duplicate=true'><img src='https://img.shields.io/badge/-Duplicate%20Space-blue?labelColor=white&style=flat&logo=data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAAXNSR0IArs4c6QAAAP5JREFUOE+lk7FqAkEURY+ltunEgFXS2sZGIbXfEPdLlnxJyDdYB62sbbUKpLbVNhyYFzbrrA74YJlh9r079973psed0cvUD4A+4HoCjsA85X0Dfn/RBLBgBDxnQPfAEJgBY+A9gALA4tcbamSzS4xq4FOQAJgCDwV2CPKV8tZAJcAjMMkUe1vX+U+SMhfAJEHasQIWmXNN3abzDwHUrgcRGmYcgKe0bxrblHEB4E/pndMazNpSZGcsZdBlYJcEL9Afo75molJyM2FxmPgmgPqlWNLGfwZGG6UiyEvLzHYDmoPkDDiNm9JR9uboiONcBXrpY1qmgs21x1QwyZcpvxt9NS09PlsPAAAAAElFTkSuQmCC&logoWidth=14'></a>
+        <br/>
+        ⚖️ You can use, modify and share the generated images but not for commercial uses.
+
+        """
+    )
+    with gr.Row():
+        with gr.Column():
+            dummy_1 = gr.Label(visible = False)
+        with gr.Column():
+            enlarge_top = gr.Number(minimum = 0, value = 64, precision = 0, label = "Uncrop on top ⬆️", info = "in pixels")
+        with gr.Column():
+            dummy_2 = gr.Label(visible = False)
+    with gr.Row():
+        with gr.Column():
+            enlarge_left = gr.Number(minimum = 0, value = 64, precision = 0, label = "Uncrop on left ⬅️", info = "in pixels")
+        with gr.Column():
+            input_image = gr.Image(label = "Your image", sources = ["upload", "webcam", "clipboard"], type = "pil")
+        with gr.Column():
+            enlarge_right = gr.Number(minimum = 0, value = 64, precision = 0, label = "Uncrop on right ➡️", info = "in pixels")
+    with gr.Row():
+        with gr.Column():
+            dummy_3 = gr.Label(visible = False)
+        with gr.Column():
+            enlarge_bottom = gr.Number(minimum = 0, value = 64, precision = 0, label = "Uncrop on bottom ⬇️", info = "in pixels")
+        with gr.Column():
+            dummy_4 = gr.Label(visible = False)
+    with gr.Row():
+        prompt = gr.Textbox(label = "Prompt", info = "Describe the subject, the background and the style of image; 77 token limit", placeholder = "Describe what you want to see in the entire image", lines = 2)
+    with gr.Row():
+        with gr.Accordion("Advanced options", open = False):
+            negative_prompt = gr.Textbox(label = "Negative prompt", placeholder = "Describe what you do NOT want to see in the entire image", value = 'Border, frame, painting, scribbling, smear, noise, blur, watermark')
+            smooth_border = gr.Slider(minimum = 0, maximum = 1024, value = 0, step = 2, label = "Smooth border", info = "lower=preserve original, higher=seamless")
+            num_inference_steps = gr.Slider(minimum = 10, maximum = 100, value = 50, step = 1, label = "Number of inference steps", info = "lower=faster, higher=image quality")
+            guidance_scale = gr.Slider(minimum = 1, maximum = 13, value = 7, step = 0.1, label = "Classifier-Free Guidance Scale", info = "lower=image quality, higher=follow the prompt")
+            image_guidance_scale = gr.Slider(minimum = 1, value = 1.5, step = 0.1, label = "Image Guidance Scale", info = "lower=image quality, higher=follow the image")
+            strength = gr.Slider(value = 0.99, minimum = 0.01, maximum = 1.0, step = 0.01, label = "Strength", info = "lower=follow the original area (discouraged), higher=redraw from scratch")
+            denoising_steps = gr.Number(minimum = 0, value = 1000, step = 1, label = "Denoising", info = "lower=irrelevant result, higher=relevant result")
+            randomize_seed = gr.Checkbox(label = "\U0001F3B2 Randomize seed", value = True, info = "If checked, result is always different")
+            seed = gr.Slider(minimum = 0, maximum = max_64_bit_int, step = 1, randomize = True, label = "Seed")
+            debug_mode = gr.Checkbox(label = "Debug mode", value = False, info = "Show intermediate results")
+
+    with gr.Row():
+        submit = gr.Button("🚀 Outpaint", variant = "primary")
+
+    with gr.Row():
+        uncropped_image = gr.Image(label = "Outpainted image")
+    with gr.Row():
+        information = gr.HTML()
+    with gr.Row():
+        original_image = gr.Image(label = "Original image", visible = False)
+    with gr.Row():
+        enlarged_image = gr.Image(label = "Enlarged image", visible = False)
+    with gr.Row():
+        mask_image = gr.Image(label = "Mask image", visible = False)
+
+    submit.click(fn = update_seed, inputs = [
+        randomize_seed,
+        seed
+    ], outputs = [
+        seed
+    ], queue = False, show_progress = False).then(toggle_debug, debug_mode, [
+        original_image,
+        enlarged_image,
+        mask_image
+    ], queue = False, show_progress = False).then(check, inputs = [
+        input_image,
+        enlarge_top,
+        enlarge_right,
+        enlarge_bottom,
+        enlarge_left,
+        prompt,
+        negative_prompt,
+        smooth_border,
+        num_inference_steps,
+        guidance_scale,
+        image_guidance_scale,
+        strength,
+        denoising_steps,
+        randomize_seed,
+        seed,
+        debug_mode
+    ], outputs = [], queue = False,
+                     show_progress = False).success(uncrop, inputs = [
+        input_image,
+        enlarge_top,
+        enlarge_right,
+        enlarge_bottom,
+        enlarge_left,
+        prompt,
+        negative_prompt,
+        smooth_border,
+        num_inference_steps,
+        guidance_scale,
+        image_guidance_scale,
+        strength,
+        denoising_steps,
+        randomize_seed,
+        seed,
+        debug_mode
+    ], outputs = [
+        uncropped_image,
+        information,
+        original_image,
+        enlarged_image,
+        mask_image
+    ], scroll_to_output = True)
+
+    gr.Examples(
+        run_on_click = True,
+        fn = uncrop,
+	    inputs = [
+            input_image,
+            enlarge_top,
+            enlarge_right,
+            enlarge_bottom,
+            enlarge_left,
+            prompt,
+            negative_prompt,
+            smooth_border,
+            num_inference_steps,
+            guidance_scale,
+            image_guidance_scale,
+            strength,
+            denoising_steps,
+            randomize_seed,
+            seed,
+            debug_mode
+        ],
+	    outputs = [
+            uncropped_image,
+            information,
+            original_image,
+            enlarged_image,
+            mask_image
         ],
-        image_encoder_folder="models/image_encoder",
+        examples = [
+                [
+                    "./examples/Coucang.jpg",
+                    1024,
+                    1024,
+                    1024,
+                    1024,
+                    "A white Coucang, in a tree, ultrarealistic, realistic, photorealistic, 8k, bokeh",
+                    "Border, frame, painting, drawing, cartoon, anime, 3d, scribbling, smear, noise, blur, watermark",
+                    0,
+                    50,
+                    7,
+                    1.5,
+                    0.99,
+                    1000,
+                    False,
+                    123,
+                    False
+                ],
+            ],
+        cache_examples = False,
     )
-    pipeline.set_ip_adapter_scale(0.1)
-
-    def generate_image(prompt, negative_prompt, image, mask, ip_adapter_image, seed: int = None):
-        if seed is None:
-            seed = random.randint(0, 2**32 - 1)
-
-        generator = torch.Generator(device="cpu").manual_seed(seed)
-
-        image = pipeline(
-            prompt=prompt,
-            negative_prompt=negative_prompt,
-            width=1024,
-            height=1024,
-            guidance_scale=guidance_scale,
-            num_inference_steps=25,
-            original_image=image,
-            image=image,
-            strength=1.0,
-            map=mask,
-            generator=generator,
-            ip_adapter_image=[ip_adapter_image],
-            output_type="np",
-        ).images[0]
-
-        image = (image * 255).astype(np.uint8)
-        image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
-
-        return image
-
-    prompt = ""
-    negative_prompt = ""
-    inpaint_mask_color = 50  # lighter use more of the Telea inpainting
-    # I recommend to don't go more than half of the picture so it has context
-    expand_pixels = 256
-
-    original = cv2.cvtColor(np.array(pil_image), cv2.COLOR_RGB2BGR)
-    image = image_resize(original)
-    # image.shape[1] for horizontal, image.shape[0] for vertical
-    expand_pixels_to_square = 1024 - image.shape[1]
-    image, mask = process_image(
-        image, expand_pixels=expand_pixels_to_square, direction=direction, inpaint_mask_color=inpaint_mask_color, blur_radius=blur_radius
+    
+    gr.Markdown(
+        """
+        ## How to prompt your image
+
+        To easily read your prompt, start with the subject, then describ the pose or action, then secondary elements, then the background, then the graphical style, then the image quality:
+        ```
+        A Vietnamese woman, red clothes, walking, smilling, in the street, a car on the left, in a modern city, photorealistic, 8k
+        ```
+
+        You can use round brackets to increase the importance of a part:
+        ```
+        A Vietnamese woman, (red clothes), walking, smilling, in the street, a car on the left, in a modern city, photorealistic, 8k
+        ```
+
+        You can use several levels of round brackets to even more increase the importance of a part:
+        ```
+        A Vietnamese woman, ((red clothes)), (walking), smilling, in the street, a car on the left, in a modern city, photorealistic, 8k
+        ```
+
+        You can use number instead of several round brackets:
+        ```
+        A Vietnamese woman, (red clothes:1.5), (walking), smilling, in the street, a car on the left, in a modern city, photorealistic, 8k
+        ```
+
+        You can do the same thing with square brackets to decrease the importance of a part:
+        ```
+        A [Vietnamese] woman, (red clothes:1.5), (walking), smilling, in the street, a car on the left, in a modern city, photorealistic, 8k
+        ```
+
+        To easily read your negative prompt, organize it the same way as your prompt (not important for the AI):
+        ```
+        man, boy, hat, running, tree, bicycle, forest, drawing, painting, cartoon, 3d, monochrome, blurry, noisy, bokeh
+        ```
+
+        ## Credit
+        The [example image](https://commons.wikimedia.org/wiki/File:Coucang.jpg) is by Aprisonsan
+        and licensed under CC-BY-SA 4.0 International.
+        """
     )
 
-    ip_adapter_image = []
-    for index, part in enumerate(slice_image(original)):
-        ip_adapter_image.append(part)
-
-    generated = generate_image(
-        prompt, negative_prompt, image, mask, ip_adapter_image)
-    final_image = generated
-
-    for i in range(times_to_expand):
-        image, mask = process_image(
-            final_image, direction=direction, expand_pixels=expand_pixels, inpaint_mask_color=inpaint_mask_color, blur_radius=blur_radius
-        )
-
-        ip_adapter_image = []
-        for index, part in enumerate(slice_image(generated)):
-            ip_adapter_image.append(part)
-
-        generated = generate_image(
-            prompt, negative_prompt, image, mask, ip_adapter_image)
-        final_image = merge_images(final_image, generated, 256, direction)
-
-    color_converted = cv2.cvtColor(final_image, cv2.COLOR_BGR2RGB)
-    return color_converted
-
-example_image=load_image('examples/Coucang.jpg')
-
-gradio_app = gr.Interface(
-    outpaint,
-    inputs=[
-        gr.Image(label="Select start image", sources=[
-                 'upload', 'clipboard'], type='pil'),
-        gr.Radio(["left", "right", "top", 'bottom'], label="Direction",
-                 info="Outward from which edge to paint?", value='right'),
-        gr.Slider(2, 4, step=1, value=4, label="Times to expand",
-                  info="Choose between 2 and 4"),
-        gr.Slider(1, 12, step=0.1, value=4, label="Guidance scale",
-                  info="Choose between 1 and 12"),
-        gr.Slider(250, 500, step=1, value=500, label="Mask blur radius",
-                  info="Choose between 250 and 500"),
-    ],
-    outputs=[gr.Image(label="Processed Image")],
-    examples=[
-        [example_image, 'right', 4, 5, 500],
-        [example_image, 'left', 4, 6, 500],
-    ],
-    title="Outpainting with differential diffusion demo",
-    description=DESCRIPTION,
-    article=ARTICLE
-)
-
-if __name__ == "__main__":
-    gradio_app.queue(max_size=20).launch()
+    interface.queue().launch()