Cherry Pick readmeMarketing Information Update

README.md

@@ -4,6 +4,7 @@ emoji: 🐝
 colorFrom: yellow
 colorTo: purple
 sdk: gradio
+python_version: 3.10.13
 sdk_version: 5.12.0
 app_file: app.py
 pinned: false
@@ -24,4 +25,42 @@ thumbnail: >-
   https://cdn-uploads.huggingface.co/production/uploads/6346595c9e5f0fe83fc60444/s0fQvcoiSBlH36AXpVwPi.png
 ---
 
+Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+
+# HexaGrid Creator
+## Description
+Welcome to HexaGrid Creator, the ultimate tool for transforming your images into mesmerizing hexagon grid masterpieces! Whether you're a tabletop game enthusiast, a digital artist, or just someone who loves unique patterns, HexaGrid Creator has something for you.
+
+### What Can You Do?
+- **Generate Hexagon Grids:** Create stunning hexagon grid overlays on any image with fully customizable parameters.
+- **AI-Powered Image Generation:** Use AI to generate images based on your prompts and apply hexagon grids to them.
+- **Color Exclusion:** Pick 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.
+- **Bee-Inspired Theme:** Enjoy a delightful yellow and purple theme inspired by bees and 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!
+
+## Contributions
+Thanks to [@Surn](https://huggingface.co/spaces/Surn/beeuty) for adding this gradio theme!
 Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

app.py

@@ -1,155 +1,618 @@
-import gradio as gr
-import numpy as np
+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 spaces
+# Import constants
+import utils.constants as constants
 
-# import spaces #[uncomment to use ZeroGPU]
-from diffusers import DiffusionPipeline
-import torch
+IS_SHARED_SPACE = constants.IS_SHARED_SPACE
 
-device = "cuda" if torch.cuda.is_available() else "cpu"
-model_repo_id = "stabilityai/sdxl-turbo"  # Replace to the model you would like to use
+# Import functions from modules
+from utils.file_utils import cleanup_temp_files
 
-if torch.cuda.is_available():
-    torch_dtype = torch.float16
-else:
-    torch_dtype = torch.float32
+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
 
-pipe = DiffusionPipeline.from_pretrained(model_repo_id, torch_dtype=torch_dtype)
-pipe = pipe.to(device)
+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
+)
 
-MAX_SEED = np.iinfo(np.int32).max
-MAX_IMAGE_SIZE = 1024
+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 infer(
-    prompt,
-    negative_prompt,
-    seed,
-    randomize_seed,
-    width,
-    height,
-    guidance_scale,
-    num_inference_steps,
-    progress=gr.Progress(track_tqdm=True),
-):
-    if randomize_seed:
-        seed = random.randint(0, MAX_SEED)
-
-    generator = torch.Generator().manual_seed(seed)
-
-    image = pipe(
-        prompt=prompt,
-        negative_prompt=negative_prompt,
-        guidance_scale=guidance_scale,
-        num_inference_steps=num_inference_steps,
-        width=width,
+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,
-        generator=generator,
-    ).images[0]
+        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
 
-    return image, seed
+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)
 
-examples = [
-    "Astronaut in a jungle, cold color palette, muted colors, detailed, 8k",
-    "An astronaut riding a green horse",
-    "A delicious ceviche cheesecake slice",
-]
+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
 
-css = """
-#col-container {
-    margin: 0 auto;
-    max-width: 640px;
-}
-"""
+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)
 
-with gr.Blocks(css=css) as demo:
-    with gr.Column(elem_id="col-container"):
-        gr.Markdown(" # Text-to-Image Gradio Template")
+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)
 
-        with gr.Row():
-            prompt = gr.Text(
-                label="Prompt",
-                show_label=False,
-                max_lines=1,
-                placeholder="Enter your prompt",
-                container=False,
-            )
+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]]
 
-            run_button = gr.Button("Run", scale=0, variant="primary")
+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.
 
-        result = gr.Image(label="Result", show_label=False)
+        ## Drop an image into the Input Image and get started!
 
-        with gr.Accordion("Advanced Settings", open=False):
-            negative_prompt = gr.Text(
-                label="Negative prompt",
-                max_lines=1,
-                placeholder="Enter a negative prompt",
-                visible=False,
-            )
+        </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.
 
-            seed = gr.Slider(
-                label="Seed",
-                minimum=0,
-                maximum=MAX_SEED,
-                step=1,
-                value=0,
+        ### 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:
 
-            randomize_seed = gr.Checkbox(label="Randomize seed", value=True)
+                        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():
-                width = gr.Slider(
-                    label="Width",
-                    minimum=256,
-                    maximum=MAX_IMAGE_SIZE,
-                    step=32,
-                    value=1024,  # Replace with defaults that work for your model
-                )
-
-                height = gr.Slider(
-                    label="Height",
-                    minimum=256,
-                    maximum=MAX_IMAGE_SIZE,
-                    step=32,
-                    value=1024,  # Replace with defaults that work for your model
-                )
+                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.Row():
-                guidance_scale = gr.Slider(
-                    label="Guidance scale",
-                    minimum=0.0,
-                    maximum=10.0,
-                    step=0.1,
-                    value=0.0,  # Replace with defaults that work for your model
-                )
-
-                num_inference_steps = gr.Slider(
-                    label="Number of inference steps",
-                    minimum=1,
-                    maximum=50,
-                    step=1,
-                    value=2,  # Replace with defaults that work for your model
-                )
-
-        gr.Examples(examples=examples, inputs=[prompt])
-    gr.on(
-        triggers=[run_button.click, prompt.submit],
-        fn=infer,
-        inputs=[
-            prompt,
-            negative_prompt,
-            seed,
-            randomize_seed,
-            width,
-            height,
-            guidance_scale,
-            num_inference_steps,
-        ],
-        outputs=[result, seed],
+    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__":
-    demo.launch()
+    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")

requirements.txt

@@ -14,11 +14,12 @@ huggingface_hub
 transformers==4.48.1
 gradio==5.12.0
 gradio[oauth]
-pillow
+Pillow
 numpy==1.26.4
 requests
 # git+https://github.com/huggingface/diffusers[torch]
 diffusers[torch]==0.32.2
+accelerate
 peft
 opencv-python
 open3d
@@ -30,4 +31,8 @@ git+https://github.com/asomoza/image_gen_aux.git
 # git+https://github.com/triton-lang/triton.git -not windows supported --disable in environment variable
 tiktoken
 pilmoji[requests]==2.0.4
-emoji==2.2.0
+emoji==2.2.0
+pycairo
+cairocffi
+pangocffi
+pangocairocffi