app.py

import gradio as gr
from PIL import Image, ImageDraw, ImageChops, ImageColor
from haishoku.haishoku import Haishoku
import os
from tempfile import NamedTemporaryFile
from pathlib import Path
import atexit
import random
# Import constants
import utils.constants as constants

IS_SHARED_SPACE = constants.IS_SHARED_SPACE

# Import functions from modules
from utils.file_utils import cleanup_temp_files

from utils.color_utils import (
    rgb_to_hex,
    hex_to_rgb,
    detect_color_format,
    update_color_opacity,
)
from utils.misc import (get_filename, pause, convert_ratio_to_dimensions)
from utils.depth_estimation import estimate_depth, create_3d_model, generate_depth_and_3d, generate_depth_button_click

from utils.image_utils import (
    change_color,
    open_image,
    build_prerendered_images,
    upscale_image,
    lerp_imagemath,
    shrink_and_paste_on_blank,
    show_lut,
    apply_lut_to_image_path,
    multiply_and_blend_images,
    alpha_composite_with_control
)

from utils.hex_grid import (
    generate_hexagon_grid,
    generate_hexagon_grid_interface,
)

from utils.excluded_colors import (
    add_color,
    delete_color,
    build_dataframe,
    on_input,
    excluded_color_list,
    on_color_display_select
)

from utils.ai_generator import (
    generate_ai_image,
)
from utils.version_info import (
    versions_html,
    get_torch_info
)
from utils.lora_details import (
    upd_prompt_notes
)

input_image_palette = []
current_prerendered_image = gr.State("./images/images/Beeuty-1.png")

# Register the cleanup function
atexit.register(cleanup_temp_files)

def hex_create(hex_size, border_size, input_image_path, start_x, start_y, end_x, end_y, rotation, background_color_hex, background_opacity, border_color_hex, border_opacity, fill_hex, excluded_colors_var, filter_color, x_spacing, y_spacing, add_hex_text_option=None, custom_text_list=None, custom_text_color_list=None):
    global input_image_palette

    try:
        # Load and process the input image
        input_image = Image.open(input_image_path).convert("RGBA")
    except Exception as e:
        print(f"Failed to convert image to RGBA: {e}")
        # Open the original image without conversion
        input_image = Image.open(input_image_path)
        # Ensure the canvas is at least 1344x768 pixels
        min_width, min_height = 1344, 768
        canvas_width = max(min_width, input_image.width)
        canvas_height = max(min_height, input_image.height)

        # Create a transparent canvas with the required dimensions
        new_canvas = Image.new("RGBA", (canvas_width, canvas_height), (0, 0, 0, 0))

        # Calculate position to center the input image on the canvas
        paste_x = (canvas_width - input_image.width) // 2
        paste_y = (canvas_height - input_image.height) // 2

        # Paste the input image onto the canvas
        new_canvas.paste(input_image, (paste_x, paste_y))

        # Save the 'RGBA' image to a temporary file and update 'input_image_path'
        with NamedTemporaryFile(delete=False, suffix=".png") as tmp_file:
            new_canvas.save(tmp_file.name, format="PNG")
            input_image_path = tmp_file.name
            constants.temp_files.append(tmp_file.name)

        # Update 'input_image' with the new image as a file path
        input_image = Image.open(input_image_path)
    
    # Use Haishoku to get the palette from the new image
    input_palette = Haishoku.loadHaishoku(input_image_path)
    input_image_palette = input_palette.palette

    # Update colors with opacity
    background_color = update_color_opacity(
        hex_to_rgb(background_color_hex),
        int(background_opacity * (255 / 100))
    )
    border_color = update_color_opacity(
        hex_to_rgb(border_color_hex),
        int(border_opacity * (255 / 100))
    )

    # Prepare excluded colors list
    excluded_color_list = [tuple(lst) for lst in excluded_colors_var]

    # Generate the hexagon grid images
    grid_image = generate_hexagon_grid_interface(
        hex_size,
        border_size,
        input_image,
        start_x,
        start_y,
        end_x,
        end_y,
        rotation,
        background_color,
        border_color,
        fill_hex,
        excluded_color_list,
        filter_color,
        x_spacing,
        y_spacing,
        add_hex_text_option,
        custom_text_list,
        custom_text_color_list
    )

    return grid_image

def get_model_and_lora(model_textbox):
    """
    Determines the model and LoRA weights based on the model_textbox input.
    wieghts must be in an array ["Borcherding/FLUX.1-dev-LoRA-FractalLand-v0.1"]
    """
    # If the input is in the list of models, return it with None as LoRA weights
    if model_textbox in constants.MODELS:
        return model_textbox, []
    # If the input is in the list of LoRA weights, get the corresponding model
    elif model_textbox in constants.LORA_WEIGHTS:
        model = constants.LORA_TO_MODEL.get(model_textbox)
        return model, model_textbox.split()
    else:
        # Default to a known model if input is unrecognized
        default_model = model_textbox
        return default_model, []

@spaces.GPU(duration=128)
def generate_input_image_click(map_option, prompt_textbox_value, negative_prompt_textbox_value, model_textbox_value, use_conditioned_image=False, strength=0.5, image_format="16:9", scale_factor=3):
    # Get the model and LoRA weights
    model, lora_weights = get_model_and_lora(model_textbox_value)
    global current_prerendered_image
    conditioned_image=None

    if use_conditioned_image:
        print(f"Conditioned path: {current_prerendered_image.value}.. converting to RGB\n")
        # ensure the conditioned image is an image and not a string, cannot use RGBA
        if isinstance(current_prerendered_image.value, str):            
            conditioned_image = open_image(current_prerendered_image.value).convert("RGB")
            print(f"Conditioned Image: {conditioned_image.size}.. converted to RGB\n")

    # Convert image_format from a string split by ":" into two numbers divided
    width_ratio, height_ratio = map(int, image_format.split(":"))
    aspect_ratio = width_ratio / height_ratio
    
    width, height = convert_ratio_to_dimensions(aspect_ratio, 512)
    
    # Generate the AI image and get the image path
    image_path = generate_ai_image(
        map_option,
        prompt_textbox_value,
        negative_prompt_textbox_value,
        model,
        lora_weights,
        conditioned_image,
        stength=strength,
        height=height,
        width=width
    )
       
    # Open the generated image
    try:
        image = Image.open(image_path).convert("RGBA")
    except Exception as e:
        print(f"Failed to open generated image: {e}")
        return image_path  # Return the original image path if opening fails
       
    # Upscale the image
    upscaled_image = upscale_image(image, scale_factor)
       
    # Save the upscaled image to a temporary file
    with NamedTemporaryFile(delete=False, suffix=".png") as tmp_upscaled:
        upscaled_image.save(tmp_upscaled.name, format="PNG")
        constants.temp_files.append(tmp_upscaled.name)
        print(f"Upscaled image saved to {tmp_upscaled.name}")
       
    # Return the path of the upscaled image
    return tmp_upscaled.name

def update_prompt_visibility(map_option):
      is_visible = (map_option == "Prompt")
      return (
          gr.update(visible=is_visible),
          gr.update(visible=is_visible),
          gr.update(visible=is_visible)
      )

def update_prompt_notes(model_textbox_value):
    return upd_prompt_notes(model_textbox_value)

def on_prerendered_gallery_selection(event_data: gr.SelectData):
    global current_prerendered_image
    selected_index = event_data.index
    selected_image = constants.pre_rendered_maps_paths[selected_index]
    print(f"Gallery Image Selected: {selected_image}\n")
    current_prerendered_image.value = selected_image
    return current_prerendered_image

def combine_images_with_lerp(input_image, output_image, alpha):
    in_image = open_image(input_image)
    out_image = open_image(output_image)
    print(f"Combining images with alpha: {alpha}")
    return lerp_imagemath(in_image, out_image, alpha)

def add_border(image, mask_width, mask_height, blank_color):
    bordered_image_output = Image.open(image).convert("RGBA")
    margin_color = detect_color_format(blank_color)
    print(f"Adding border to image with width: {mask_width}, height: {mask_height}, color: {margin_color}")
    return shrink_and_paste_on_blank(bordered_image_output, mask_width, mask_height, margin_color)

title = "HexaGrid Creator"
description = "Customizable Hexagon Grid Image Generator"
examples = [["assets//examples//hex_map_p1.png", 32, 1, 0, 0, 0, 0, 0, "#ede9ac44","#12165380", True]]

gr.set_static_paths(paths=["images/","images/images","images/prerendered","LUT/","fonts/"])
# Gradio Blocks Interface
with gr.Blocks(css_paths="style_20250128.css", title="HexaGrid Creator", theme='Surn/beeuty') as beeuty:
    with gr.Row():
        gr.Markdown ("""
        # HexaGrid Creator
        ## Transform Your Images into Mesmerizing Hexagon Grid Masterpieces! ⬢
        <details>
        <summary>
        Welcome to HexaGrid Creator, the ultimate tool for transforming your images into stunning hexagon grid artworks. Whether you're a tabletop game enthusiast, a digital artist, or someone who loves unique patterns, HexaGrid Creator has something for you.

        ## Drop an image into the Input Image and get started!

        </summary>

        ## What is HexaGrid Creator?
        HexaGrid Creator is a web-based application that allows you to apply a hexagon grid overlay to any image. You can customize the size, color, and opacity of the hexagons, as well as the background and border colors. The result is a visually striking image that looks like it was made from hexagonal tiles!

        ### What Can You Do?
        - **Generate Hexagon Grids:** Create beautiful hexagon grid overlays on any image with fully customizable parameters.
        - **AI-Powered Image Generation:** Use advanced AI models to generate images based on your prompts and apply hexagon grids to them.
        - **Color Exclusion:** Select and exclude specific colors from your hexagon grid for a cleaner and more refined look.
        - **Interactive Customization:** Adjust hexagon size, border size, rotation, background color, and more in real-time.
        - **Depth and 3D Model Generation:** Generate depth maps and 3D models from your images for enhanced visualization.
        - **Image Filter [Look-Up Table (LUT)] Application:** Apply filters (LUTs) to your images for color grading and enhancement.
        - **Pre-rendered Maps:** Access a library of pre-rendered hexagon maps for quick and easy customization.
        - **Add Margins:** Add customizable margins around your images for a polished finish.

        ### Why You'll Love It
        - **Fun and Easy to Use:** With an intuitive interface and real-time previews, creating hexagon grids has never been this fun!
        - **Endless Creativity:** Unleash your creativity with endless customization options and see your images transform in unique ways.
        - **Hexagon-Inspired Theme:** Enjoy a delightful yellow and purple theme inspired by hexagons! ⬢
        - **Advanced AI Models:** Leverage advanced AI models and LoRA weights for high-quality image generation and customization.

        ### Get Started
        1. **Upload or Generate an Image:** Start by uploading your own image or generate one using our AI-powered tool.
        2. **Customize Your Grid:** Play around with the settings to create the perfect hexagon grid overlay.
        3. **Download and Share:** Once you're happy with your creation, download it and share it with the world!

        ### Advanced Features
        - **Generative AI Integration:** Utilize models like `black-forest-labs/FLUX.1-dev` and various LoRA weights for generating unique images.
        - **Pre-rendered Maps:** Access a library of pre-rendered hexagon maps for quick and easy customization.
        - **Image Filter [Look-Up Table (LUT)] Application:** Apply filters (LUTs) to your images for color grading and enhancement.
        - **Depth and 3D Model Generation:** Create depth maps and 3D models from your images for enhanced visualization.
        - **Add Margins:** Customize margins around your images for a polished finish.

        Join the hive and start creating with HexaGrid Creator today!
        </details>
        """, elem_classes="intro")
    with gr.Row():
        with gr.Column(scale=2):
            input_image = gr.Image(
                label="Input Image",
                type="filepath",
                interactive=True,
                elem_classes="centered solid imgcontainer",
                key="imgInput",
                image_mode="RGBA",
                format="PNG"
            )
        with gr.Column():
            with gr.Accordion("Hex Coloring and Exclusion", open = False):
                with gr.Row():
                    with gr.Column():
                        color_picker = gr.ColorPicker(label="Pick a color to exclude",value="#505050")
                    with gr.Column():
                        filter_color = gr.Checkbox(label="Filter Excluded Colors from Sampling", value=False,)
                exclude_color_button = gr.Button("Exclude Color", elem_id="exlude_color_button", elem_classes="solid")
                color_display = gr.DataFrame(label="List of Excluded RGBA Colors", headers=["R", "G", "B", "A"], elem_id="excluded_colors", type="array", value=build_dataframe(excluded_color_list), interactive=True, elem_classes="solid centered")
                selected_row = gr.Number(0, label="Selected Row", visible=False)
                delete_button = gr.Button("Delete Row", elem_id="delete_exclusion_button", elem_classes="solid")
                fill_hex = gr.Checkbox(label="Fill Hex with color from Image", value=True)
            with gr.Accordion("Image Filters", open = False):
                with gr.Row():
                    with gr.Column():
                        composite_color = gr.ColorPicker(label="Color", value="#ede9ac44")
                    with gr.Column():
                        composite_opacity = gr.Slider(label="Opacity %", minimum=0, maximum=100, value=50, interactive=True)
                with gr.Row():
                    composite_button = gr.Button("Composite", elem_classes="solid")
                with gr.Row():
                    with gr.Column():
                        lut_filename = gr.Textbox(
                            value="", 
                            label="Look Up Table (LUT) File Name",
                            elem_id="lutFileName")
                    with gr.Column():
                        lut_file = gr.File(
                            value=None,
                            file_count="single",
                            file_types=[".cube"],
                            type="filepath",
                            label="LUT cube File")
                with gr.Row():
                    lut_example_image = gr.Image(type="pil", label="Filter (LUT) Example Image", value=constants.default_lut_example_img)
                with gr.Row():
                    with gr.Column():
                        gr.Markdown("""
                        ### Included Filters (LUTs)
                        There are several included Filters:

                        Try them on the example image before applying to your Input Image.
                        """, elem_id="lut_markdown")
                    with gr.Column():
                        gr.Examples(elem_id="lut_examples",
                            examples=[[f] for f in constants.lut_files],
                            inputs=[lut_filename],
                            outputs=[lut_filename],
                            label="Select a Filter (LUT) file. Populate the LUT File Name field"
                        )
                    
                with gr.Row():
                    apply_lut_button = gr.Button("Apply Filter (LUT)", elem_classes="solid", elem_id="apply_lut_button")
                    
                lut_file.change(get_filename, inputs=[lut_file], outputs=[lut_filename])
                lut_filename.change(show_lut, inputs=[lut_filename, lut_example_image], outputs=[lut_example_image])
                apply_lut_button.click(apply_lut_to_image_path, inputs=[lut_filename, input_image], outputs=[input_image],scroll_to_output=True)

    with gr.Row():
        with gr.Accordion("Generative AI", open = False):
            with gr.Row():
                with gr.Column():
                    model_options = gr.Dropdown(
                        label="Model Options",
                        choices=constants.MODELS + constants.LORA_WEIGHTS + ["Manual Entry"],
                        value="Cossale/Frames2-Flex.1",
                        elem_classes="solid"
                    )
                    model_textbox = gr.Textbox(
                        label="LORA/Model",
                        value="Cossale/Frames2-Flex.1",
                        elem_classes="solid",
                        elem_id="inference_model",
                        visible=False
                    )
                    # Update map_options to a Dropdown with choices from constants.PROMPTS keys
                    with gr.Row():
                        with gr.Column():
                                map_options = gr.Dropdown(
                                label="Map Options",
                                choices=list(constants.PROMPTS.keys()),
                                value="Alien Landscape",
                                elem_classes="solid"
                            )
                        with gr.Column():
                            # Add Dropdown for sizing of Images, height and width based on selection. Options are 16x9, 16x10, 4x5, 1x1
                            # The values of height and width are based on common resolutions for each aspect ratio
                            # Default to 16x9, 912x512
                            image_size_ratio = gr.Dropdown(label="Image Size", choices=["16:9", "16:10", "4:5", "4:3", "2:1","3:2","1:1", "9:16", "10:16", "5:4", "3:4","1:2", "2:3"], value="16:9", elem_classes="solid", type="value",interactive=True)
                    prompt_textbox = gr.Textbox(
                        label="Prompt",
                        visible=False,
                        elem_classes="solid",
                        value="top-down, (tabletop_map built from small hexagon pieces) hexagon map of a Battletech_boardgame forest with lakes, forest, magic fauna, and snow at the top and bottom, (middle is dark, no_reflections, no_shadows) , tall and short hexagon tiles. Viewed from above.",
                        lines=4
                    )
                    negative_prompt_textbox = gr.Textbox(
                        label="Negative Prompt",
                        visible=False,
                        elem_classes="solid",
                        value="low quality, bad anatomy, blurry, cropped, worst quality, shadows, people, humans, reflections, shadows, realistic map of the Earth, isometric, text"
                    )
                    prompt_notes_label = gr.Label(
                        "You should use FRM$ as trigger words. @1.5 minutes",
                        elem_classes="solid centered small",
                        show_label=False,
                        visible=False
                    )
                    # Keep the change event to maintain functionality
                    map_options.change(
                        fn=update_prompt_visibility,
                        inputs=[map_options],
                        outputs=[prompt_textbox, negative_prompt_textbox, prompt_notes_label]
                    )
                    with gr.Row():
                        generate_input_image = gr.Button(
                            "Generate AI Image",
                            elem_id="generate_input_image",
                            elem_classes="solid"
                    )
                with gr.Column(scale=2):
                     with gr.Accordion("Template Image Styles", open = False):
                         with gr.Row():
                            # Gallery from PRE_RENDERED_IMAGES GOES HERE
                            prerendered_image_gallery = gr.Gallery(label="Image Gallery", show_label=True, value=build_prerendered_images(constants.pre_rendered_maps_paths), elem_id="gallery", elem_classes="solid", type="filepath", columns=[3], rows=[3], preview=False ,object_fit="contain", height="auto",file_types=["image"], format="png",allow_preview=False)
                         with gr.Row():
                             image_guidance_stength = gr.Slider(label="Image Guidance Strength", minimum=0, maximum=1.0, value=0.5, step=0.05, interactive=True)
                             with gr.Column():
                                 replace_input_image_button = gr.Button(
                                     "Replace Input Image",
                                     elem_id="prerendered_replace_input_image_button",
                                     elem_classes="solid"
                                 )
                             with gr.Column():
                                 generate_input_image_from_gallery = gr.Button(
                                     "Generate AI Image from Gallery",
                                     elem_id="generate_input_image_from_gallery",
                                     elem_classes="solid"
                                 )

    with gr.Accordion("Advanced Hexagon Settings", open = False):
        with gr.Row():
            start_x = gr.Number(label="Start X", value=0, minimum=-512, maximum= 512, precision=0)
            start_y = gr.Number(label="Start Y", value=0, minimum=-512, maximum= 512, precision=0)
            end_x = gr.Number(label="End X", value=0, minimum=-512, maximum= 512, precision=0)
            end_y = gr.Number(label="End Y", value=0, minimum=-512, maximum= 512, precision=0)
        with gr.Row():
            x_spacing = gr.Number(label="Adjust Horizontal spacing", value=-1, minimum=-200, maximum=200, precision=1)
            y_spacing = gr.Number(label="Adjust Vertical spacing", value=1, minimum=-200, maximum=200, precision=1)
        with gr.Row():
            rotation = gr.Slider(-90, 180, 0.0, 0.1, label="Hexagon Rotation (degree)")
            add_hex_text = gr.Dropdown(label="Add Text to Hexagons", choices=[None, "Row-Column Coordinates", "Sequential Numbers", "Playing Cards Sequential", "Playing Cards Alternate Red and Black", "Custom List"], value=None)
        with gr.Row():
            custom_text_list = gr.TextArea(label="Custom Text List", value=constants.cards_alternating, visible=False,)
            custom_text_color_list = gr.TextArea(label="Custom Text Color List", value=constants.card_colors_alternating, visible=False)
        with gr.Row():
            hex_text_info = gr.Markdown("""
            ### Text Color uses the Border Color and Border Opacity, unless you use a custom list.
            ### The Custom Text List and Custom Text Color List are comma separated lists.
            ### The custom color list is a comma separated list of hex colors.
            #### Example: "A,2,3,4,5,6,7,8,9,10,J,Q,K", "red,#0000FF,#00FF00,red,#FFFF00,#00FFFF,#FF8000,#FF00FF,#FF0080,#FF8000,#FF0080,lightblue"
            """, elem_id="hex_text_info", visible=False)
        add_hex_text.change(
        fn=lambda x: (
            gr.update(visible=(x == "Custom List")), 
            gr.update(visible=(x == "Custom List")),
            gr.update(visible=(x != None))
            ),
            inputs=add_hex_text,
            outputs=[custom_text_list, custom_text_color_list, hex_text_info]
        )
    with gr.Row():
        hex_size = gr.Number(label="Hexagon Size", value=32, minimum=1, maximum=768)
        border_size = gr.Slider(-5,25,value=0,step=1,label="Border Size")
    with gr.Row():        
        background_color = gr.ColorPicker(label="Background Color", value="#000000", interactive=True)
        background_opacity = gr.Slider(0,100,0,1,label="Background Opacity %")
        border_color = gr.ColorPicker(label="Border Color", value="#7b7b7b", interactive=True)
        border_opacity = gr.Slider(0,100,0,1,label="Border Opacity %")
    with gr.Row():
        hex_button = gr.Button("Generate Hex Grid!", elem_classes="solid", elem_id="btn-generate")
    with gr.Row():
        output_image = gr.Image(label="Hexagon Grid Image", image_mode = "RGBA", show_download_button=True, show_share_button=True,elem_classes="centered solid imgcontainer", format="PNG", type="filepath", key="ImgOutput")
        overlay_image = gr.Image(label="Hexagon Overlay Image", image_mode = "RGBA", show_share_button=True, elem_classes="centered solid imgcontainer", format="PNG", type="filepath", key="ImgOverlay")
    with gr.Row():
        output_overlay_composite = gr.Slider(0,100,50,0.5, label="Interpolate Intensity")
        output_blend_multiply_composite = gr.Slider(0,100,50,0.5, label="Overlay Intensity")
        output_alpha_composite = gr.Slider(0,100,50,0.5, label="Alpha Composite Intensity")
    with gr.Accordion("Add Margins (bleed)", open=False):
        with gr.Row():
            border_image_source = gr.Radio(label="Add Margins around which Image", choices=["Input Image", "Overlay Image"], value="Overlay Image")
        with gr.Row():
            mask_width = gr.Number(label="Margins Width", value=10, minimum=0, maximum=100, precision=0)
            mask_height = gr.Number(label="Margins Height", value=10, minimum=0, maximum=100, precision=0)
        with gr.Row():
                margin_color = gr.ColorPicker(label="Margin Color", value="#333333FF", interactive=True)
                margin_opacity = gr.Slider(0,100,95,0.5,label="Margin Opacity %")
        with gr.Row():
            add_border_button = gr.Button("Add Margins", elem_classes="solid", variant="secondary")
        with gr.Row():
            bordered_image_output = gr.Image(label="Image with Margins", image_mode="RGBA", show_download_button=True, show_share_button=True, elem_classes="centered solid imgcontainer", format="PNG", type="filepath", key="ImgBordered")

    with gr.Accordion("Height Maps and 3D", open = False):
        with gr.Row():
            with gr.Column():
                voxel_size_factor = gr.Slider(label="Voxel Size Factor", value=1.00, minimum=0.01, maximum=40.00, step=0.01)
            with gr.Column():
                depth_image_source = gr.Radio(label="Depth Image Source", choices=["Input Image", "Output Image", "Overlay Image","Image with Margins"], value="Input Image")
        with gr.Row():
            generate_depth_button = gr.Button("Generate Depth Map and 3D Model From Selected Image", elem_classes="solid", variant="secondary")
        with gr.Row():
            depth_map_output = gr.Image(label="Depth Map", image_mode="L", elem_classes="centered solid imgcontainer", format="PNG", type="filepath", key="ImgDepth")
            model_output = gr.Model3D(label="3D Model", clear_color=[1.0, 1.0, 1.0, 0.25], key="Img3D", elem_classes="centered solid imgcontainer")
    with gr.Row():
        gr.Examples(examples=[
            ["assets//examples//hex_map_p1.png", False, True, -32,-31,80,80,-1.8,0,35,0,1,"#FFD0D0", 15],
            ["assets//examples//hex_map_p1_overlayed.png", False, False, -32,-31,80,80,-1.8,0,35,0,1,"#FFD0D0", 75],
            ["assets//examples//hex_flower_logo.png", False, True, -95,-95,100,100,-24,-2,190,30,2,"#FF8951", 50],
            ["assets//examples//hexed_fract_1.png", False, True, 0,0,0,0,0,0,10,0,0,"#000000", 5],
            ["assets//examples//tmpzt3mblvk.png", False, True, -20,10,0,0,-6,-2,35,30,1,"#ffffff", 0],
            ],
            inputs=[input_image, filter_color, fill_hex, start_x, start_y, end_x, end_y, x_spacing, y_spacing, hex_size, rotation, border_size, border_color, border_opacity],
            elem_id="examples")
    with gr.Row():
        gr.HTML(value=versions_html(), visible=True, elem_id="versions")

    color_display.select(on_color_display_select,inputs=[color_display], outputs=[selected_row])
    color_display.input(on_input,inputs=[color_display], outputs=[color_display, gr.State(excluded_color_list)])

    delete_button.click(fn=delete_color, inputs=[selected_row, color_display], outputs=[color_display])
    exclude_color_button.click(fn=add_color, inputs=[color_picker, gr.State(excluded_color_list)], outputs=[color_display, gr.State(excluded_color_list)])
    hex_button.click(hex_create, inputs=[hex_size, border_size, input_image, start_x, start_y, end_x, end_y, rotation, background_color, background_opacity, border_color, border_opacity, fill_hex, color_display, filter_color, x_spacing, y_spacing, add_hex_text, custom_text_list, custom_text_color_list], outputs=[output_image, overlay_image], scroll_to_output=True)
    generate_input_image.click(
        fn=generate_input_image_click,
        inputs=[map_options, prompt_textbox, negative_prompt_textbox, model_textbox, gr.State(False), gr.State(0.5), image_size_ratio],
        outputs=[input_image], scroll_to_output=True
    )
    generate_depth_button.click(
        fn=generate_depth_button_click,
        inputs=[depth_image_source, voxel_size_factor, input_image, output_image, overlay_image, bordered_image_output],
        outputs=[depth_map_output, model_output], scroll_to_output=True
    )
    model_textbox.change(
        fn=update_prompt_notes,
        inputs=model_textbox,
        outputs=prompt_notes_label,preprocess=False
    )
    model_options.change(
        fn=lambda x: (gr.update(visible=(x == "Manual Entry")), gr.update(value=x) if x != "Manual Entry" else gr.update()),
        inputs=model_options,
        outputs=[model_textbox, model_textbox]
    )
    model_options.change(
        fn=update_prompt_notes,
        inputs=model_options,
        outputs=prompt_notes_label
    )
    composite_button.click(
        fn=change_color,
        inputs=[input_image, composite_color, composite_opacity],
        outputs=[input_image]
    )

    #use conditioned_image as the input_image for generate_input_image_click
    generate_input_image_from_gallery.click(
        fn=generate_input_image_click,
        inputs=[map_options, prompt_textbox, negative_prompt_textbox, model_textbox, gr.State(True), image_guidance_stength, image_size_ratio],
        outputs=[input_image], scroll_to_output=True
    )

    # Update the state variable with the prerendered image filepath when an image is selected
    prerendered_image_gallery.select(
        fn=on_prerendered_gallery_selection, 
        inputs=None, 
        outputs=[gr.State(current_prerendered_image)],  # Update the state with the selected image
        show_api=False
    )
    # replace input image with selected gallery image
    replace_input_image_button.click(
        lambda: current_prerendered_image.value,
        inputs=None,
        outputs=[input_image], scroll_to_output=True
    )
    output_overlay_composite.change(
        fn=combine_images_with_lerp,
        inputs=[input_image, output_image, output_overlay_composite],
        outputs=[overlay_image], scroll_to_output=True
    )
    output_blend_multiply_composite.change(
        fn=multiply_and_blend_images,
        inputs=[input_image, output_image, output_blend_multiply_composite],
        outputs=[overlay_image],
        scroll_to_output=True
    )
    output_alpha_composite.change(
        fn=alpha_composite_with_control,
        inputs=[input_image, output_image, output_alpha_composite],
        outputs=[overlay_image],
        scroll_to_output=True
    )
    add_border_button.click(
        fn=lambda image_source, mask_w, mask_h, color, opacity, input_img, overlay_img: add_border(input_img if image_source == "Input Image" else overlay_img, mask_w, mask_h, update_color_opacity(detect_color_format(color), opacity * 2.55)),
        inputs=[border_image_source, mask_width, mask_height, margin_color, margin_opacity, input_image, overlay_image],
        outputs=[bordered_image_output],
        scroll_to_output=True
    )
(())
if __name__ == "__main__":
    beeuty.queue(default_concurrency_limit=1,max_size=12,api_open=False)
    beeuty.launch(allowed_paths=["assets","/","./assets","images","./images", "./images/prerendered"], favicon_path="./assets/favicon.ico", max_file_size="10mb")