Spaces:
Runtime error
Runtime error
| from diffusers import StableDiffusionXLInpaintPipeline | |
| import gradio as gr | |
| import numpy as np | |
| import time | |
| import math | |
| import random | |
| import imageio | |
| from PIL import Image, ImageFilter | |
| import torch | |
| max_64_bit_int = 2**63 - 1 | |
| device = "cuda" if torch.cuda.is_available() else "cpu" | |
| floatType = torch.float16 if torch.cuda.is_available() else torch.float32 | |
| pipe = StableDiffusionXLInpaintPipeline.from_pretrained("diffusers/stable-diffusion-xl-1.0-inpainting-0.1", torch_dtype = floatType) | |
| pipe = pipe.to(device) | |
| 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, | |
| denoising_steps, | |
| num_inference_steps, | |
| guidance_scale, | |
| image_guidance_scale, | |
| strength, | |
| 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, | |
| denoising_steps, | |
| num_inference_steps, | |
| guidance_scale, | |
| image_guidance_scale, | |
| strength, | |
| randomize_seed, | |
| seed, | |
| debug_mode, | |
| progress = gr.Progress()): | |
| check( | |
| input_image, | |
| enlarge_top, | |
| enlarge_right, | |
| enlarge_bottom, | |
| enlarge_left, | |
| prompt, | |
| negative_prompt, | |
| smooth_border, | |
| denoising_steps, | |
| num_inference_steps, | |
| guidance_scale, | |
| image_guidance_scale, | |
| strength, | |
| 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 denoising_steps is None: | |
| denoising_steps = 1000 | |
| 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 | |
| if strength is None: | |
| strength = 0.99 | |
| if randomize_seed: | |
| seed = random.randint(0, max_64_bit_int) | |
| random.seed(seed) | |
| #pipe = pipe.manual_seed(seed) | |
| 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 | |
| # 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 = secondes // 60 | |
| secondes = secondes - (minutes * 60) | |
| hours = minutes // 60 | |
| minutes = minutes - (hours * 60) | |
| return [ | |
| output_image, | |
| "Start again to get a different result. 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 have been generated in " + str(hours) + " h, " + str(minutes) + " min, " + str(secondes) + " sec." + limitation, | |
| input_image, | |
| enlarged_image, | |
| mask_image | |
| ] | |
| def toggle_debug(is_debug_mode): | |
| if is_debug_mode: | |
| return [gr.update(visible = True)] * 3 | |
| else: | |
| return [gr.update(visible = False)] * 3 | |
| with gr.Blocks() as interface: | |
| gr.Markdown( | |
| """ | |
| <p style="text-align: center;"><b><big><big><big>Uncrop</big></big></big></b></p> | |
| <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. For illustration purpose, not information purpose. The new content is not based on real information but imagination. | |
| <br/> | |
| <ul> | |
| <li>To change the <b>view angle</b> of your image, I recommend to use <i>Zero123</i>,</li> | |
| <li>To <b>upscale</b> your image, I recommend to use <i>Ilaria Upscaler</i>,</li> | |
| <li>To <b>slightly change</b> your image, I recommend to use <i>Image-to-Image SDXL</i>,</li> | |
| <li>To change <b>one detail</b> on your image, I recommend to use <i>Inpaint SDXL</i>,</li> | |
| <li>To remove the <b>background</b> of your image, I recommend to use <i>BRIA</i>,</li> | |
| <li>To make a <b>tile</b> of your image, I recommend to use <i>Make My Image Tile</i>,</li> | |
| <li>To modify <b>anything else</b> on your image, I recommend to use <i>Instruct Pix2Pix</i>.</li> | |
| </ul> | |
| <br/> | |
| 🐌 Slow process... ~1 hour.<br>You can duplicate this space on a free account, it works on CPU and should also run on CUDA.<br/> | |
| <a href='https://huggingface.co/spaces/Fabrice-TIERCELIN/Uncrop?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 = "Enlarge 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 = "Enlarge on left ⬅️", info = "in pixels") | |
| with gr.Column(): | |
| input_image = gr.Image(label = "Your image", sources = ["upload"], type = "pil") | |
| with gr.Column(): | |
| enlarge_right = gr.Number(minimum = 0, value = 64, precision = 0, label = "Enlarge 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 = "Enlarge 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') | |
| 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") | |
| denoising_steps = gr.Slider(minimum = 0, maximum = 1000, value = 1000, step = 1, label = "Denoising", info = "lower=irrelevant result, higher=relevant result") | |
| 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.Number(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") | |
| randomize_seed = gr.Checkbox(label = "\U0001F3B2 Randomize seed (not working, always checked)", 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 (if not randomized)") | |
| debug_mode = gr.Checkbox(label = "Debug mode", value = False, info = "Show intermediate results") | |
| with gr.Row(): | |
| submit = gr.Button("Uncrop", variant = "primary") | |
| with gr.Row(): | |
| uncropped_image = gr.Image(label = "Uncropped image") | |
| with gr.Row(): | |
| information = gr.Label(label = "Information") | |
| 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(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, | |
| denoising_steps, | |
| num_inference_steps, | |
| guidance_scale, | |
| image_guidance_scale, | |
| strength, | |
| 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, | |
| denoising_steps, | |
| num_inference_steps, | |
| guidance_scale, | |
| image_guidance_scale, | |
| strength, | |
| randomize_seed, | |
| seed, | |
| debug_mode | |
| ], outputs = [ | |
| uncropped_image, | |
| information, | |
| original_image, | |
| enlarged_image, | |
| mask_image | |
| ], scroll_to_output = True) | |
| gr.Examples( | |
| inputs = [ | |
| input_image, | |
| enlarge_top, | |
| enlarge_right, | |
| enlarge_bottom, | |
| enlarge_left, | |
| prompt, | |
| negative_prompt, | |
| smooth_border, | |
| denoising_steps, | |
| num_inference_steps, | |
| guidance_scale, | |
| image_guidance_scale, | |
| strength, | |
| randomize_seed, | |
| seed, | |
| debug_mode | |
| ], | |
| outputs = [ | |
| uncropped_image, | |
| information, | |
| original_image, | |
| enlarged_image, | |
| mask_image | |
| ], | |
| examples = [ | |
| [ | |
| "Example1.webp", | |
| 1024, | |
| 1024, | |
| 1024, | |
| 1024, | |
| "A woman, black hair, nowadays, in the street, ultrarealistic, realistic, photorealistic, 8k", | |
| "Border, frame, painting, drawing, cartoon, scribbling, smear, noise, blur, watermark", | |
| 0, | |
| 1000, | |
| 50, | |
| 7, | |
| 1.5, | |
| 0.99, | |
| True, | |
| 42, | |
| False | |
| ], | |
| [ | |
| "Example2.png", | |
| 1024, | |
| 1024, | |
| 1024, | |
| 1024, | |
| "A man, jumping in the air, outside, ultrarealistic, realistic, photorealistic, 8k", | |
| "Border, frame, painting, drawing, cartoon, scribbling, smear, noise, blur, watermark", | |
| 0, | |
| 1000, | |
| 50, | |
| 7, | |
| 1.5, | |
| 0.99, | |
| True, | |
| 42, | |
| False | |
| ], | |
| [ | |
| "Example3.jpg", | |
| 0, | |
| 512, | |
| 0, | |
| 512, | |
| "An old yellow car, in a town, ultrarealistic, realistic, photorealistic, 8k", | |
| "Border, frame, painting, drawing, cartoon, scribbling, smear, noise, blur, watermark", | |
| 0, | |
| 1000, | |
| 50, | |
| 7, | |
| 1.5, | |
| 0.99, | |
| True, | |
| 42, | |
| False | |
| ], | |
| ], | |
| cache_examples = False, | |
| ) | |
| interface.queue().launch() |