import spaces import gradio as gr from PIL import Image 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 ( 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, [] def generate_input_image_click(map_option, prompt_textbox_value, negative_prompt_textbox_value, model_textbox_value, seed=None, use_conditioned_image=False, strength=0.5, image_format="16:9", scale_factor=3, progress=gr.Progress(track_tqdm=True)): # 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, seed=seed ) # 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! ⬢""", elem_classes="intro") with gr.Row(): with gr.Accordion("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.", open=False, elem_classes="intro"): gr.Markdown (""" ## Drop an image into the Input Image and get started! ## 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! """, elem_classes="intro") with gr.Row(): from utils.image_utils import convert_to_rgba_png # Existing code 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=None, format="PNG", show_download_button=True, ) # New code to convert input image to RGBA PNG def on_input_image_change(image_path): if image_path is None: gr.Warning("Please upload an Input Image to get started.") return None img, img_path = convert_to_rgba_png(image_path) return img_path input_image.change( fn=on_input_image_change, inputs=[input_image], outputs=[input_image], scroll_to_output=True, ) 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( lambda lut_filename, input_image: gr.Warning("Please upload an Input Image to get started.") if input_image is None else apply_lut_to_image_path(lut_filename, input_image)[0], 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", scale=0 ) 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", scale=0, interactive=True) with gr.Column(): seed = gr.Slider( label="Seed", minimum=0, maximum=constants.MAX_SEED, step=1, value=0, scale=0 ) randomize_seed = gr.Checkbox(label="Randomize seed", value=True, scale=0, 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( fn=lambda 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: gr.Warning("Please upload an Input Image to get started.") if input_image is None else hex_create(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), 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( seed if randomize_seed==False else random.randint(0, constants.MAX_SEED)), 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=lambda input_image, composite_color, composite_opacity: gr.Warning("Please upload an Input Image to get started.") if input_image is None else change_color(input_image, composite_color, composite_opacity), 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")