app.py

import gradio as gr
import numpy as np
import time
import math
import random
import imageio
import torch

from diffusers import AutoPipelineForImage2Image
from PIL import Image, ImageFilter

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
variant = "fp16" if torch.cuda.is_available() else None

pipe = AutoPipelineForImage2Image.from_pretrained("Fabrice-TIERCELIN/sdxl-turbo", 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):
    if is_debug_mode:
        return [gr.update(visible = True)]
    return [gr.update(visible = False)]

def check(
    source_img,
    prompt,
    negative_prompt,
    num_inference_steps,
    guidance_scale,
    image_guidance_scale,
    strength,
    denoising_steps,
    seed,
    debug_mode,
    progress = gr.Progress()
):
    if source_img is None:
        raise gr.Error("Please provide an image.")

    if prompt is None or prompt == "":
        raise gr.Error("Please provide a prompt input.")

def redraw(
    source_img,
    prompt,
    negative_prompt,
    num_inference_steps,
    guidance_scale,
    image_guidance_scale,
    strength,
    denoising_steps,
    seed,
    debug_mode,
    progress = gr.Progress()
):
    check(
        source_img,
        prompt,
        negative_prompt,
        num_inference_steps,
        guidance_scale,
        image_guidance_scale,
        strength,
        denoising_steps,
        seed,
        debug_mode
    )
    start = time.time()
    progress(0, desc = "Preparing data...")

    if negative_prompt is None:
        negative_prompt = ""

    if num_inference_steps is None:
        num_inference_steps = 25

    if guidance_scale is None:
        guidance_scale = 7

    if image_guidance_scale is None:
        image_guidance_scale = 1.1

    if strength is None:
        strength = 0.5

    if denoising_steps is None:
        denoising_steps = 1000

    if seed is None:
        seed = random.randint(0, max_64_bit_int)

    random.seed(seed)
    torch.manual_seed(seed)

    input_image = source_img.convert("RGB")

    original_height, original_width, original_channel = np.array(input_image).shape
    output_width = original_width
    output_height = original_height

    # 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)

    process_width = 1024
    process_height = 1024

    output_width = 1024
    output_height = 1024

    progress(None, desc = "Processing...")
    output_image = pipe(
        seeds = [seed],
        width = process_width,
        height = process_height,
        prompt = prompt,
        negative_prompt = negative_prompt,
        image = input_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

    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
    ]

with gr.Blocks() as interface:
    gr.Markdown(
        """
        <p style="text-align: center;"><b><big><big><big>Image-to-Image</big></big></big></b></p>
        <p style="text-align: center;">Modifies the global render of your image, at any resolution, freely, without account, without watermark, without installation, which can be downloaded</p>
        <br/>
        <br/>
        🚀 Powered by <i>SDXL Turbo</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 change one <b>detail</b> on your image, I recommend to use <i>Inpaint SDXL</i>,</li>
        <li>If you need to enlarge the <b>viewpoint</b> of your image, I recommend you to use <i>Uncrop</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... ~2 hours. Your computer must not enter into standby mode.<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/Image-to-Image?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.Column():
        source_img = gr.Image(label = "Your image", sources = ["upload", "webcam", "clipboard"], type = "pil")
        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")
        strength = gr.Slider(value = 0.5, minimum = 0.01, maximum = 1.0, step = 0.01, label = "Strength", info = "lower=follow the original image, higher=follow the prompt")
        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 = "Ugly, malformed, noise, blur, watermark")
             num_inference_steps = gr.Slider(minimum = 10, maximum = 100, value = 25, 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.1, step = 0.1, label = "Image Guidance Scale", info = "lower=image quality, higher=follow the image")
             denoising_steps = gr.Slider(minimum = 0, maximum = 1000, 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")

        submit = gr.Button("Redraw", variant = "primary")

        redrawn_image = gr.Image(label = "Redrawn image")
        information = gr.Label(label = "Information")
        original_image = gr.Image(label = "Original image", visible = False)

    submit.click(update_seed, inputs = [
        randomize_seed, seed
    ], outputs = [
        seed
    ], queue = False, show_progress = False).then(toggle_debug, debug_mode, [
        original_image
    ], queue = False, show_progress = False).then(check, inputs = [
        source_img,
        prompt,
        negative_prompt,
        num_inference_steps,
        guidance_scale,
        image_guidance_scale,
        strength,
        denoising_steps,
        seed,
        debug_mode
    ], outputs = [], queue = False, show_progress = False).success(redraw, inputs = [
        source_img,
        prompt,
        negative_prompt,
        num_inference_steps,
        guidance_scale,
        image_guidance_scale,
        strength,
        denoising_steps,
        seed,
        debug_mode
    ], outputs = [
        redrawn_image,
        information,
        original_image
    ], scroll_to_output = True)

    gr.Examples(
        fn = redraw,
	    inputs = [
            source_img,
            prompt,
            negative_prompt,
            num_inference_steps,
            guidance_scale,
            image_guidance_scale,
            strength,
            denoising_steps,
            seed,
            debug_mode
        ],
	    outputs = [
            redrawn_image,
            information,
            original_image
        ],
        examples = [
                [
                    "./Examples/Example1.png",
                    "Drawn image, line art, illustration, picture",
                    "3d, photo, realistic, noise, blur, watermark",
                    25,
                    7,
                    1.1,
                    0.6,
                    1000,
                    42,
                    False
                ],
            ],
        cache_examples = False,
    )
    
    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
        ```
        """
    )

    interface.queue().launch()