app.py

import os
import random
import base64
import gradio as gr
from PIL import Image
from gradio_client import Client
import numpy as np
from io import BytesIO

DESCRIPTION = "# SDXL Texture"

MAX_SEED = np.iinfo(np.int32).max
MAX_IMAGE_SIZE = int(os.getenv("MAX_IMAGE_SIZE", "1024"))
ENABLE_REFINER = os.getenv("ENABLE_REFINER", "1") == "1"

def randomize_seed_fn(seed: int, randomize_seed: bool) -> int:
    if randomize_seed:
        seed = random.randint(0, MAX_SEED)
    return seed

def generate_normal_map(image):
    if not isinstance(image, Image.Image):
        image = Image.open(BytesIO(image))
        
    # Convert image to grayscale
    grayscale = image.convert("L")
    grayscale_np = np.array(grayscale)
    
    # Compute gradients
    grad_x, grad_y = np.gradient(grayscale_np.astype(float))
    
    # Normalize gradients
    grad_x = (grad_x - grad_x.min()) / (grad_x.max() - grad_x.min())
    grad_y = (grad_y - grad_y.min()) / (grad_y.max() - grad_y.min())
    
    # Create normal map
    normal_map = np.dstack((grad_x, grad_y, np.ones_like(grad_x)))
    normal_map = (normal_map * 255).astype(np.uint8)
    
    return Image.fromarray(normal_map)

def generate_image(
    prompt: str,
    additional_prompt: str = "",
    negative_prompt: str = "",
    use_negative_prompt: bool = False,
    seed: int = 0,
    width: int = 1024,
    height: int = 1024,
    guidance_scale_base: float = 5.0,
    guidance_scale_refiner: float = 5.0,
    num_inference_steps_base: int = 25,
    num_inference_steps_refiner: int = 25,
    apply_refiner: bool = False,
):
    if additional_prompt != "":
        additional_prompt += ", "
    
    client = Client("hysts/SDXL")
    image = client.predict(
        prompt=additional_prompt+prompt,
        negative_prompt=negative_prompt,
        prompt_2="",
        negative_prompt_2="",
        use_negative_prompt=use_negative_prompt,
        use_prompt_2=False,
        use_negative_prompt_2=False,
        seed=seed,
        width=width,
        height=height,
        guidance_scale_base=guidance_scale_base,
        guidance_scale_refiner=guidance_scale_refiner,
        num_inference_steps_base=num_inference_steps_base,
        num_inference_steps_refiner=num_inference_steps_refiner,
        apply_refiner=apply_refiner,
        api_name="/predict",
    )
    normal_map = generate_normal_map(Image.open(image))
    return image, normal_map

examples = [
    "A texture of grey wood, close-up, high contrast",
    "A 4K texture of cobblestone, sharp rocks, hd material",
    "A texture of white marble, light grey, seamless",
]

with gr.Blocks(css="style.css") as demo:
    gr.Markdown(DESCRIPTION)
    with gr.Group():
        with gr.Row():
            prompt = gr.Textbox(
                label="Prompt",
                show_label=False,
                max_lines=1,
                placeholder="Enter your prompt",
                container=False,
            )
            run_button = gr.Button("Run", scale=0)
        with gr.Row():
            result_image = gr.Image(label="Texture", show_label=True)
            result_normal = gr.Image(label="Normal", show_label=True)
    with gr.Accordion("Advanced options", open=False):
        use_negative_prompt = gr.Checkbox(label="Use negative prompt", value=True)
        negative_prompt = gr.Textbox(
            label="Negative prompt",
            max_lines=1,
            placeholder="Enter a negative prompt",
            visible=True,
            value="anatomy, text, logos, faces, animals, recognizable objects, cube, sphere, human, hands",
        )
        additional_prompt = gr.Textbox(
            label="Additional prompt",
            max_lines=1,
            placeholder="Enter an additional prompt",
            visible=True,
            value="((Seamless texture)), versatile pattern, high resolution, detailed design, subtle patterns, non-repetitive, smooth edges, square",
        )
        seed = gr.Slider(
            label="Seed",
            minimum=0,
            maximum=MAX_SEED,
            step=1,
            value=0,
        )
        randomize_seed = gr.Checkbox(label="Randomize seed", value=True)
        with gr.Row():
            width = gr.Slider(
                label="Width",
                minimum=256,
                maximum=MAX_IMAGE_SIZE,
                step=32,
                value=1024,
            )
            height = gr.Slider(
                label="Height",
                minimum=256,
                maximum=MAX_IMAGE_SIZE,
                step=32,
                value=1024,
            )
        apply_refiner = gr.Checkbox(label="Apply refiner", value=False, visible=ENABLE_REFINER)
        with gr.Row():
            guidance_scale_base = gr.Slider(
                label="Guidance scale for base",
                minimum=1,
                maximum=20,
                step=0.1,
                value=5.0,
            )
            num_inference_steps_base = gr.Slider(
                label="Number of inference steps for base",
                minimum=10,
                maximum=100,
                step=1,
                value=25,
            )
        with gr.Row(visible=False) as refiner_params:
            guidance_scale_refiner = gr.Slider(
                label="Guidance scale for refiner",
                minimum=1,
                maximum=20,
                step=0.1,
                value=5.0,
            )
            num_inference_steps_refiner = gr.Slider(
                label="Number of inference steps for refiner",
                minimum=10,
                maximum=100,
                step=1,
                value=25,
            )

    gr.Examples(
        examples=examples,
        cache_examples=False,
        inputs=prompt,
        outputs=[result_image, result_normal],
        fn=generate_image,
    )
    use_negative_prompt.change(
        fn=lambda x: gr.update(visible=x),
        inputs=use_negative_prompt,
        outputs=negative_prompt,
        queue=False,
        api_name=False,
    )
    apply_refiner.change(
        fn=lambda x: gr.update(visible=x),
        inputs=apply_refiner,
        outputs=refiner_params,
        queue=False,
        api_name=False,
    )

    gr.on(
        triggers=[
            prompt.submit,
            additional_prompt.submit,
            negative_prompt.submit,
            run_button.click,
        ],
        fn=randomize_seed_fn,
        inputs=[seed, randomize_seed],
        outputs=seed,
        queue=False,
        api_name=False,
    ).then(
        fn=generate_image,
        inputs=[
            prompt,
            additional_prompt,
            negative_prompt,
            use_negative_prompt,
            seed,
            width,
            height,
            guidance_scale_base,
            guidance_scale_refiner,
            num_inference_steps_base,
            num_inference_steps_refiner,
            apply_refiner,
        ],
        outputs=[result_image, result_normal],
        api_name="run",
    )

if __name__ == "__main__":
    demo.queue(max_size=20).launch(ssr_mode=False)