Revision update 0.5.21

lora_gallery (preview)
new luts
more hexagon text options
faster loading
Gradio 5.21.0
Fill model

README.md

@@ -5,7 +5,7 @@ colorFrom: yellow
 colorTo: purple
 sdk: gradio
 python_version: 3.10.13
-sdk_version: 5.20.1
+sdk_version: 5.21.0
 app_file: app.py
 pinned: true
 short_description: Transform Your Images into Mesmerizing Hexagon Grids

app.py

@@ -11,11 +11,12 @@ from PIL import Image, ImageFilter
 from easydict import EasyDict as edict
 import utils.constants as constants
 from haishoku.haishoku import Haishoku
+from tqdm import tqdm
 
 from tempfile import NamedTemporaryFile
 import atexit
 import random
-#import accelerate 
+import accelerate 
 from transformers import AutoTokenizer, DPTImageProcessor, DPTForDepthEstimation
 from trellis.pipelines import TrellisImageTo3DPipeline
 from trellis.representations import Gaussian, MeshExtractResult
@@ -40,14 +41,14 @@ from utils.misc import (
     get_filename, 
     pause, 
     convert_ratio_to_dimensions,
+    update_dimensions_on_ratio,
     get_seed,
-    get_output_name
+    get_output_name    
     ) #install_cuda_toolkit,install_torch, _get_output, setup_runtime_env)
 
 from utils.image_utils import (
     change_color,
     open_image,
-    build_prerendered_images_by_quality,
     upscale_image,
     lerp_imagemath,
     shrink_and_paste_on_blank,
@@ -56,10 +57,12 @@ from utils.image_utils import (
     multiply_and_blend_images,
     alpha_composite_with_control,
     crop_and_resize_image,
+    resize_and_crop_image,
     convert_to_rgba_png,
     resize_image_with_aspect_ratio,
     build_prerendered_images_by_quality,
-    get_image_from_dict
+    get_image_from_dict,
+    calculate_optimal_fill_dimensions
 )
 
 from utils.hex_grid import (
@@ -82,16 +85,28 @@ from utils.excluded_colors import (
 
 from utils.lora_details import (
     upd_prompt_notes,
+    upd_prompt_notes_by_index,
     split_prompt_precisely,
     approximate_token_count,
-    get_trigger_words
+    get_trigger_words,
+    is_lora_loaded,
+    get_lora_models
+)
+from diffusers import (
+    FluxPipeline,
+    FluxImg2ImgPipeline,
+    FluxControlPipeline,
+    FluxControlPipeline,
+    DiffusionPipeline, 
+    AutoencoderTiny, 
+    AutoencoderKL
 )
-from diffusers import FluxPipeline,FluxImg2ImgPipeline,FluxControlPipeline
 
 PIPELINE_CLASSES = {
     "FluxPipeline": FluxPipeline,
     "FluxImg2ImgPipeline": FluxImg2ImgPipeline,
-    "FluxControlPipeline": FluxControlPipeline
+    "FluxControlPipeline": FluxControlPipeline,
+    "FluxFillPipeline": FluxControlPipeline
 }
 
 from utils.version_info import (
@@ -103,8 +118,15 @@ from utils.version_info import (
 #from utils.depth_estimation import (get_depth_map_from_state)
 
 input_image_palette = []
-current_prerendered_image = gr.State("./images/images/Beeuty-1.png")
+current_prerendered_image = gr.State("./images/Beeuty-1.png")
 user_dir = constants.TMPDIR
+lora_models = get_lora_models()
+selected_index = gr.State(value=-1)
+
+image_processor: Optional[DPTImageProcessor] = None
+depth_model: Optional[DPTForDepthEstimation] = None
+TRELLIS_PIPELINE: Optional[TrellisImageTo3DPipeline] = None
+pipe: Optional[Union[FluxPipeline, FluxImg2ImgPipeline, FluxControlPipeline]] = None
 
 # Register the cleanup function
 atexit.register(cleanup_temp_files)
@@ -209,18 +231,149 @@ def get_model_and_lora(model_textbox):
         default_model = model_textbox
         return default_model, []
 
-condition_dict = {
-    "depth": 0,
-    "canny": 1,
-    "subject": 4,
-    "coloring": 6,
-    "deblurring": 7,
-    "fill": 9,
-}
+def set_pipeline(
+    model_name="black-forest-labs/FLUX.1-dev",
+    lora_weights=None,
+    pipeline_name="FluxPipeline",
+    progress=gr.Progress(track_tqdm=True)
+):      
+    global pipe
+    pbar = tqdm(total=7, desc="Pipeline and Model Load")
+    current_pipeline_name =pipe.name_or_path if pipe else None
+    current_pipeline_class = type(pipe).__name__ if pipe else None
+    if (current_pipeline_name != model_name) or (pipeline_name != current_pipeline_class):
+        pipe = None
+        gc.collect()
+        #from torch import cuda, bfloat16, float32, Generator, no_grad, backends
+        # Retrieve the pipeline class from the mapping
+        pipeline_class = PIPELINE_CLASSES.get(pipeline_name)
+        if not pipeline_class:
+            raise ValueError(f"Unsupported pipeline type '{pipeline_name}'. "
+                            f"Available options: {list(PIPELINE_CLASSES.keys())}")
+
+        #initialize_cuda()
+        dvc = "cpu"
+        #from src.condition import Condition
+        pbar.update(1)
+        print(f"device:{device}\nmodel_name:{model_name}\nlora_weights:{lora_weights}\n")
+        #print(f"\n {get_torch_info()}\n")
+        # Initialize the pipeline inside the context manager
+        pipe = pipeline_class.from_pretrained(
+            model_name,
+            torch_dtype=torch.bfloat16 if device == "cuda" else torch.float16,
+            vae=good_vae
+        )
+        pbar.update(2)
+        pipe.to(dvc)
+        # Optionally, don't use CPU offload if not necessary
+        pbar.update(1)
+
+        # Access the tokenizer from the pipeline
+        tokenizer = pipe.tokenizer
+
+        # Check if add_prefix_space is set and convert to slow tokenizer if necessary
+        if getattr(tokenizer, 'add_prefix_space', False):
+            tokenizer = AutoTokenizer.from_pretrained(model_name, use_fast=True, device_map = 'cpu')
+            # Update the pipeline's tokenizer
+            pipe.tokenizer = tokenizer
+            
+    pbar.set_description("Loading LoRA weights")
+    pbar.update(1)
+    pipe.unload_lora_weights()
+    
+    # Load LoRA weights
+    # note: does not yet handle multiple LoRA weights with different names, needs .set_adapters(["depth", "hyper-sd"], adapter_weights=[0.85, 0.125])
+    if lora_weights:
+        for lora_weight in lora_weights:
+            lora_configs = constants.LORA_DETAILS.get(lora_weight, [])
+            lora_weight_set = False
+            if lora_configs:
+                for config in lora_configs:
+                    # Load LoRA weights with optional weight_name and adapter_name
+                    if 'weight_name' in config:
+                        weight_name = config.get("weight_name")
+                        adapter_name = config.get("adapter_name")
+                        lora_collection = config.get("lora_collection")
+                        if weight_name and adapter_name and lora_collection and lora_weight_set == False:
+                            pipe.load_lora_weights(
+                                lora_collection,
+                                weight_name=weight_name,
+                                adapter_name=adapter_name,
+                                token=constants.HF_API_TOKEN
+                            )
+                            lora_weight_set = True
+                            print(f"\npipe.load_lora_weights({lora_weight}, weight_name={weight_name}, adapter_name={adapter_name}, lora_collection={lora_collection}\n")  
+                        elif weight_name and adapter_name==None and lora_collection and lora_weight_set == False:
+                            pipe.load_lora_weights(
+                                lora_collection,
+                                weight_name=weight_name,
+                                token=constants.HF_API_TOKEN
+                            )
+                            lora_weight_set = True
+                            print(f"\npipe.load_lora_weights({lora_weight}, weight_name={weight_name}, adapter_name={adapter_name}, lora_collection={lora_collection}\n")  
+                        elif weight_name and adapter_name and lora_weight_set == False:
+                            pipe.load_lora_weights(
+                                lora_weight,
+                                weight_name=weight_name,
+                                adapter_name=adapter_name,
+                                token=constants.HF_API_TOKEN
+                            )
+                            lora_weight_set = True
+                            print(f"\npipe.load_lora_weights({lora_weight}, weight_name={weight_name}, adapter_name={adapter_name}\n")  
+                        elif weight_name and adapter_name==None and lora_weight_set == False:
+                            pipe.load_lora_weights(
+                                lora_weight,
+                                weight_name=weight_name,
+                                token=constants.HF_API_TOKEN
+                            )
+                            lora_weight_set = True
+                            print(f"\npipe.load_lora_weights({lora_weight}, weight_name={weight_name}, adapter_name={adapter_name}\n")  
+                        elif lora_weight_set == False:
+                            pipe.load_lora_weights(
+                                lora_weight,
+                                token=constants.HF_API_TOKEN
+                            )  
+                            lora_weight_set = True
+                            print(f"\npipe.load_lora_weights({lora_weight}, weight_name={weight_name}, adapter_name={adapter_name}\n")  
+                    # Apply 'pipe' configurations if present
+                    if 'pipe' in config:
+                        pipe_config = config['pipe']
+                        for method_name, params in pipe_config.items():
+                            method = getattr(pipe, method_name, None)
+                            if method:
+                                print(f"Applying pipe method: {method_name} with params: {params}")
+                                method(**params)
+                            else:
+                                print(f"Method {method_name} not found in pipe.")
+                    if 'condition_type' in config:
+                        condition_type = config['condition_type']
+                        if condition_type == "coloring":
+                            #pipe.enable_coloring()
+                            print("\nEnabled coloring.\n")
+                        elif condition_type == "deblurring":
+                            #pipe.enable_deblurring()
+                            print("\nEnabled deblurring.\n")
+                        elif condition_type == "fill":
+                            #pipe.enable_fill()
+                            print("\nEnabled fill.\n")
+                        elif condition_type == "depth":
+                            #pipe.enable_depth()
+                            print("\nEnabled depth.\n")
+                        elif condition_type == "canny":
+                            #pipe.enable_canny()
+                            print("\nEnabled canny.\n")
+                        elif condition_type == "subject":
+                            #pipe.enable_subject()
+                            print("\nEnabled subject.\n")
+                        else:
+                            print(f"Condition type {condition_type} not implemented.")
+            else:
+                pipe.load_lora_weights(lora_weight, use_auth_token=constants.HF_API_TOKEN)
+    pbar.set_description("Pipe Loaded.")
+    pbar.set_postfix({"Status": "Done"})
+    pbar.update(1)
+    pbar.close()
 
-# @spaces.GPU(duration=140, progress=gr.Progress(track_tqdm=True))
-# def generate_image(pipe, generate_params, progress=gr.Progress(track_tqdm=True)):
-#     return pipe(**generate_params)
 
 @spaces.GPU(duration=200, progress=gr.Progress(track_tqdm=True))
 def generate_image_lowmem(
@@ -229,6 +382,7 @@ def generate_image_lowmem(
     model_name="black-forest-labs/FLUX.1-dev",
     lora_weights=None,
     conditioned_image=None,
+    mask_image=None,
     image_width=1368,
     image_height=848,
     guidance_scale=3.5,
@@ -240,28 +394,18 @@ def generate_image_lowmem(
     additional_parameters=None,
     progress=gr.Progress(track_tqdm=True)
 ):  
-    #from torch import cuda, bfloat16, float32, Generator, no_grad, backends
-    # Retrieve the pipeline class from the mapping
-    pipeline_class = PIPELINE_CLASSES.get(pipeline_name)
-    if not pipeline_class:
-        raise ValueError(f"Unsupported pipeline type '{pipeline_name}'. "
-                        f"Available options: {list(PIPELINE_CLASSES.keys())}")
-
-    #initialize_cuda()
-    device = "cuda" if torch.cuda.is_available() else "cpu"
-    from src.condition import Condition
-
-    print(f"device:{device}\nmodel_name:{model_name}\nlora_weights:{lora_weights}\n")
-    #print(f"\n {get_torch_info()}\n")
-    # Disable gradient calculations
     with torch.no_grad():
-        # Initialize the pipeline inside the context manager
-        pipe = pipeline_class.from_pretrained(
-            model_name,
-            torch_dtype=torch.bfloat16 if device == "cuda" else torch.float32
-        ).to(device)
-        # Optionally, don't use CPU offload if not necessary
-        
+        #global pipe
+        global device
+        pipe.to(device)
+        flash_attention_enabled = torch.backends.cuda.flash_sdp_enabled()
+        if flash_attention_enabled == False:
+            #Enable xFormers memory-efficient attention (optional)
+            #pipe.enable_xformers_memory_efficient_attention()
+            print("\nEnabled xFormers memory-efficient attention.\n")
+        else:            
+            pipe.attn_implementation="flash_attention_2"
+            print("\nEnabled flash_attention_2.\n")
         # alternative version that may be more efficient
         # pipe.enable_sequential_cpu_offload()
         if pipeline_name == "FluxPipeline":
@@ -271,127 +415,34 @@ def generate_image_lowmem(
         else:
             pipe.enable_model_cpu_offload()
 
-        # Access the tokenizer from the pipeline
-        tokenizer = pipe.tokenizer
 
-        # Check if add_prefix_space is set and convert to slow tokenizer if necessary
-        if getattr(tokenizer, 'add_prefix_space', False):
-            tokenizer = AutoTokenizer.from_pretrained(model_name, use_fast=False, device_map = 'cpu')
-            # Update the pipeline's tokenizer
-            pipe.tokenizer = tokenizer
-            pipe.to(device)
-
-        flash_attention_enabled = torch.backends.cuda.flash_sdp_enabled()
-        if flash_attention_enabled == False:
-            #Enable xFormers memory-efficient attention (optional)
-            #pipe.enable_xformers_memory_efficient_attention()
-            print("\nEnabled xFormers memory-efficient attention.\n")
-        else:            
-            pipe.attn_implementation="flash_attention_2"
-            print("\nEnabled flash_attention_2.\n")
+        mask_parameters = {}
+        # Load the mask image if provided
+        if (pipeline_name == "FluxFillPipeline"):
+            mask_image = open_image(mask_image).convert("RGBA")
+            mask_condition_type = constants.condition_type[5]
+            guidance_scale = 30
+            num_inference_steps=50
+            max_sequence_length=512
+            print(f"\nAdded mask image.\n {mask_image.size}")
+            mask_parameters ={
+                "mask_image": mask_image,
+            }
 
-        condition_type = "subject"
-        # Load LoRA weights
-        # note: does not yet handle multiple LoRA weights with different names, needs .set_adapters(["depth", "hyper-sd"], adapter_weights=[0.85, 0.125])        
-        if lora_weights:
-            for lora_weight in lora_weights:
-                lora_configs = constants.LORA_DETAILS.get(lora_weight, [])
-                lora_weight_set = False
-                if lora_configs:
-                    for config in lora_configs:
-                        # Load LoRA weights with optional weight_name and adapter_name
-                        if 'weight_name' in config:
-                            weight_name = config.get("weight_name")
-                            adapter_name = config.get("adapter_name")
-                            lora_collection = config.get("lora_collection")
-                            if weight_name and adapter_name and lora_collection and lora_weight_set == False:
-                                pipe.load_lora_weights(
-                                    lora_collection,
-                                    weight_name=weight_name,
-                                    adapter_name=adapter_name,
-                                    token=constants.HF_API_TOKEN
-                                )
-                                lora_weight_set = True
-                                print(f"\npipe.load_lora_weights({lora_weight}, weight_name={weight_name}, adapter_name={adapter_name}, lora_collection={lora_collection}\n")  
-                            elif weight_name and adapter_name==None and lora_collection and lora_weight_set == False:
-                                pipe.load_lora_weights(
-                                    lora_collection,
-                                    weight_name=weight_name,
-                                    token=constants.HF_API_TOKEN
-                                )
-                                lora_weight_set = True
-                                print(f"\npipe.load_lora_weights({lora_weight}, weight_name={weight_name}, adapter_name={adapter_name}, lora_collection={lora_collection}\n")  
-                            elif weight_name and adapter_name and lora_weight_set == False:
-                                pipe.load_lora_weights(
-                                    lora_weight,
-                                    weight_name=weight_name,
-                                    adapter_name=adapter_name,
-                                    token=constants.HF_API_TOKEN
-                                )
-                                lora_weight_set = True
-                                print(f"\npipe.load_lora_weights({lora_weight}, weight_name={weight_name}, adapter_name={adapter_name}\n")  
-                            elif weight_name and adapter_name==None and lora_weight_set == False:
-                                pipe.load_lora_weights(
-                                    lora_weight,
-                                    weight_name=weight_name,
-                                    token=constants.HF_API_TOKEN
-                                )
-                                lora_weight_set = True
-                                print(f"\npipe.load_lora_weights({lora_weight}, weight_name={weight_name}, adapter_name={adapter_name}\n")  
-                            elif lora_weight_set == False:
-                                pipe.load_lora_weights(
-                                    lora_weight,
-                                    token=constants.HF_API_TOKEN
-                                )  
-                                lora_weight_set = True
-                                print(f"\npipe.load_lora_weights({lora_weight}, weight_name={weight_name}, adapter_name={adapter_name}\n")  
-                        # Apply 'pipe' configurations if present
-                        if 'pipe' in config:
-                            pipe_config = config['pipe']
-                            for method_name, params in pipe_config.items():
-                                method = getattr(pipe, method_name, None)
-                                if method:
-                                    print(f"Applying pipe method: {method_name} with params: {params}")
-                                    method(**params)
-                                else:
-                                    print(f"Method {method_name} not found in pipe.")
-                        if 'condition_type' in config:
-                            condition_type = config['condition_type']
-                            if condition_type == "coloring":
-                                #pipe.enable_coloring()
-                                print("\nEnabled coloring.\n")
-                            elif condition_type == "deblurring":
-                                #pipe.enable_deblurring()
-                                print("\nEnabled deblurring.\n")
-                            elif condition_type == "fill":
-                                #pipe.enable_fill()
-                                print("\nEnabled fill.\n")
-                            elif condition_type == "depth":
-                                #pipe.enable_depth()
-                                print("\nEnabled depth.\n")
-                            elif condition_type == "canny":
-                                #pipe.enable_canny()
-                                print("\nEnabled canny.\n")
-                            elif condition_type == "subject":
-                                #pipe.enable_subject()
-                                print("\nEnabled subject.\n")
-                            else:
-                                print(f"Condition type {condition_type} not implemented.")
-                else:
-                    pipe.load_lora_weights(lora_weight, use_auth_token=constants.HF_API_TOKEN)
         # Set the random seed for reproducibility
         generator = torch.Generator(device=device).manual_seed(seed)
-        conditions = []
+        #conditions = []
         if conditioned_image is not None:
-            conditioned_image = crop_and_resize_image(conditioned_image, image_width, image_height)
-            condition = Condition(condition_type, conditioned_image)
-            conditions.append(condition)
+            conditioned_image = resize_and_crop_image(conditioned_image, image_width, image_height)
+            #condition = Condition(constants.condition_type[2], conditioned_image)
+            #conditions.append(condition)
             print(f"\nAdded conditioned image.\n {conditioned_image.size}")
             # Prepare the parameters for image generation
             additional_parameters ={
                 "strength": strength,
                 "image": conditioned_image,
             }
+            additional_parameters.update(mask_parameters)
         else:
             print("\nNo conditioned image provided.")
             if neg_prompt!=None:
@@ -405,11 +456,11 @@ def generate_image_lowmem(
             prompt, prompt2 = split_prompt_precisely(text)
             prompt_parameters = {
                 "prompt" : prompt,
-                "prompt_2": prompt2
+                "prompt_2": prompt2,
             }
         else:
             prompt_parameters = {
-                "prompt" :text
+                "prompt" :text,
         }
         additional_parameters.update(prompt_parameters)
         # Combine all parameters
@@ -418,24 +469,29 @@ def generate_image_lowmem(
             "width": image_width,
             "guidance_scale": guidance_scale,
             "num_inference_steps": num_inference_steps,
-            "generator": generator,        }
+            "generator": generator,
+        }
         if additional_parameters:
             generate_params.update(additional_parameters)
         generate_params = {k: v for k, v in generate_params.items() if v is not None}
         print(f"generate_params: {generate_params}")
         # Generate the image
-        result = pipe(**generate_params) #generate_image(pipe,generate_params)
-        image = result.images[0]
-        # Clean up
-        del result
-        del conditions
-        del generator
-    # Delete the pipeline and clear cache
-    del pipe
+        try:
+            result = pipe(**generate_params) #generate_image(pipe,generate_params)
+            image = result.images[0]
+            # Clean up
+            del result
+        except Exception as e:
+            print(f"Error generating image: {e}")
+            image = open_image("./images/Beeuty-1.png")
+    #del conditions
+    del generator
+    # Move the pipeline and clear cache
+    pipe.to("cpu")
     torch.cuda.empty_cache()
     torch.cuda.ipc_collect()
     print(torch.cuda.memory_summary(device=None, abbreviated=False))
-    
+    gc.collect()
     return image
 
 def generate_ai_image_local (
@@ -445,6 +501,7 @@ def generate_ai_image_local (
     model="black-forest-labs/FLUX.1-dev",
     lora_weights=None,
     conditioned_image=None,
+    mask_image=None,
     height=512,
     width=912,
     num_inference_steps=30,
@@ -453,7 +510,7 @@ def generate_ai_image_local (
     pipeline_name="FluxPipeline",
     strength=0.75,
     progress=gr.Progress(track_tqdm=True)
-):        
+):    
     print(f"Generating image with lowmem")
     try:
         if map_option != "Prompt":
@@ -496,12 +553,19 @@ def generate_ai_image_local (
         print(f"Conditioned Image: {conditioned_image}")
         print(f"Conditioned Image Strength: {strength}")
         print(f"pipeline: {pipeline_name}")
+        set_pipeline(
+            model_name=model,
+            lora_weights=lora_weights,
+            pipeline_name=pipeline_name,
+            progress=progress
+        )
         image = generate_image_lowmem(
             text=prompt,
             model_name=model,
             neg_prompt=negative_prompt,
             lora_weights=lora_weights,
             conditioned_image=conditioned_image,
+            mask_image=mask_image,
             image_width=width,
             image_height=height,
             guidance_scale=guidance_scale,
@@ -509,7 +573,8 @@ def generate_ai_image_local (
             seed=seed,
             pipeline_name=pipeline_name,
             strength=strength,
-            additional_parameters=additional_parameters
+            additional_parameters=additional_parameters,
+            progress=progress
         )
         with NamedTemporaryFile(delete=False, suffix=".png") as tmp:
             image.save(tmp.name, format="PNG")
@@ -518,11 +583,11 @@ def generate_ai_image_local (
             return tmp.name
     except Exception as e:
         print(f"Error generating AI image: {e}")
-        #gc.collect()
+        gc.collect()
         return None
 
 
-def generate_input_image_click(image_input, map_option, prompt_textbox_value, negative_prompt_textbox_value, model_textbox_value, randomize_seed=True, seed=None, use_conditioned_image=False, strength=0.5, image_format="16:9", scale_factor=(8/3), progress=gr.Progress(track_tqdm=True)):
+def generate_input_image_click(image_input, map_option, prompt_textbox_value, negative_prompt_textbox_value, model_textbox_value, randomize_seed=True, seed=None, use_conditioned_image=False, mask_image=None, strength=0.5, image_format="16:9", scale_factor=constants.SCALE_FACTOR, progress=gr.Progress(track_tqdm=True)):
     seed = get_seed(randomize_seed, seed)
 
     # Get the model and LoRA weights
@@ -539,18 +604,28 @@ def generate_input_image_click(image_input, map_option, prompt_textbox_value, ne
             print(f"Conditioned Image: {conditioned_image.size}.. converted to RGB\n")
     # use image_input as the conditioned_image if it is not None
     elif image_input is not None:
-        conditioned_image =  open_image(image_input).convert("RGB")
-        print(f"Conditioned Image set to modify Input Image!\nClear to generate new image.")
-        gr.Info("Conditioned Image set to modify Input Image! Clear to generate new image",duration=5)
+        file_path, is_dict = get_image_from_dict(image_input)
+        conditioned_image =  open_image(file_path).convert("RGB")
+        print(f"Conditioned Image set to modify Input Image!\nClear to generate new image from layered image: {is_dict}\n")
+        gr.Info(f"Conditioned Image set to modify Input Image! Clear to generate new image. Layered: {is_dict}",duration=5)
 
     # 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, 576)
+    width, height = convert_ratio_to_dimensions(aspect_ratio, constants.BASE_HEIGHT)
     pipeline = "FluxPipeline"
     if conditioned_image is not None:
         pipeline = "FluxImg2ImgPipeline"
+
+    if (model == "black-forest-labs/FLUX.1-Fill-dev"):
+        pipeline = "FluxFillPipeline"
+        width, height = calculate_optimal_fill_dimensions(conditioned_image)
+        mask_image = get_image_from_dict(mask_image)
+        print(f"Optimal Dimensions: {width} x {height} \n")
+    else:
+        mask_image = None
+
     # Generate the AI image and get the image path
     image_path = generate_ai_image_local(
         map_option,
@@ -559,6 +634,7 @@ def generate_input_image_click(image_input, map_option, prompt_textbox_value, ne
         model,
         lora_weights,
         conditioned_image,
+        mask_image,
         strength=strength,
         height=height,
         width=width,
@@ -596,6 +672,23 @@ def update_prompt_visibility(map_option):
 def update_prompt_notes(model_textbox_value):
     return upd_prompt_notes(model_textbox_value)
 
+def update_selection(evt: gr.SelectData, aspect_ratio):
+    selected_lora = constants.LORAS[evt.index]
+    new_placeholder = f"Type a prompt for {selected_lora['title']}"
+    new_aspect_ratio = aspect_ratio  # default to the currently selected aspect ratio
+    lora_repo = selected_lora["repo"]
+    #updated_text = f"### Selected: [{lora_repo}](https://huggingface.co/{lora_repo}) ✅"
+    # If the selected LoRA model specifies an aspect ratio, use it to update dimensions.
+    if "aspect" in selected_lora:
+        try:
+            new_aspect_ratio = selected_lora["aspect"]
+            # Recalculate dimensions using constants.BASE_HEIGHT as the height reference.
+            new_width, new_height = update_dimensions_on_ratio(new_aspect_ratio, constants.BASE_HEIGHT)
+            # (Optionally, you could log or use new_width/new_height as needed)
+        except Exception as e:
+            print(f"\nError in update selection aspect ratios: {e}\nSkipping")
+    return [gr.update(value=lora_repo), gr.update(value=lora_repo), evt.index, new_aspect_ratio, upd_prompt_notes_by_index(evt.index)]
+
 def on_prerendered_gallery_selection(event_data: gr.SelectData):
     global current_prerendered_image
     selected_index = event_data.index
@@ -632,9 +725,12 @@ def update_sketch_dimensions(input_image, sketch_image):
     sk_img_path, _ = get_image_from_dict(sketch_image)
     sk_img = open_image(sk_img_path)
     # Resize sketch image if dimensions don't match input image.
-    if in_img.size != sk_img.size:
+    if (in_img) and (in_img.size != sk_img.size):
         sk_img = sk_img.resize(in_img.size, Image.LANCZOS)
-    return [sk_img, gr.update(width=in_img.width, height=in_img.height)]
+        return [sk_img, gr.update(width=in_img.width, height=in_img.height)]
+    else:
+        return [sk_img, gr.update()]
+    
 
 def composite_with_control_sync(input_image, sketch_image, slider_value):
     # Load the images using open_image() if they are provided as file paths.
@@ -655,7 +751,36 @@ def replace_input_with_sketch_image(sketch_image):
     sketch, is_dict = get_image_from_dict(sketch_image)
     return sketch
 ####################################### DEPTH ESTIMATION #######################################
-
+def load_3d_models(is_open: bool = True) -> bool:
+    if is_open:
+        gr.Info("Loading 3D models...")
+        global image_processor, depth_model, TRELLIS_PIPELINE
+        image_processor = DPTImageProcessor.from_pretrained("Intel/dpt-large")
+        depth_model = DPTForDepthEstimation.from_pretrained("Intel/dpt-large", ignore_mismatched_sizes=True)
+        TRELLIS_PIPELINE = TrellisImageTo3DPipeline.from_pretrained("JeffreyXiang/TRELLIS-image-large")
+        try:
+            # Preload with a dummy image to finalize initialization
+            TRELLIS_PIPELINE.preprocess_image(Image.fromarray(np.zeros((256, 256, 3), dtype=np.uint8)))
+        except Exception as e:
+            print(f"Error preloading TRELLIS_PIPELINE: {e}")
+        print("3D models loaded")
+        gr.Info("3D models loaded.")
+    return gr.update(interactive = is_open)
+
+def unload_3d_models(is_open: bool = False) -> bool:
+    if not is_open:
+        gr.Info("Unloading 3D models...")
+        global image_processor, depth_model, TRELLIS_PIPELINE
+        TRELLIS_PIPELINE.to("cpu")
+        del image_processor
+        del depth_model
+        del TRELLIS_PIPELINE
+        #torch.cuda.empty_cache()
+        #torch.cuda.ipc_collect()
+        gc.collect()
+        print("3D models unloaded and CUDA memory freed")
+        gr.Info("3D models unloaded.")
+    return gr.update(interactive = is_open)
 
 def preprocess_image(image: Image.Image) -> Image.Image:
     """
@@ -796,6 +921,7 @@ def generate_3d_asset_part2(depth_img, image_path, output_name, seed, steps, mod
     depth_img = Image.open(depth_img).convert("RGBA")
     # Preprocess and run the Trellis pipeline with fixed sampler settings
     try:
+        TRELLIS_PIPELINE.to(device)
         processed_image = TRELLIS_PIPELINE.preprocess_image(resized_image, max_resolution=model_resolution)
         outputs = TRELLIS_PIPELINE.run(
             processed_image,
@@ -930,7 +1056,7 @@ examples = [["assets//examples//hex_map_p1.png", 32, 1, 0, 0, 0, 0, 0, "#ede9ac4
 gr.set_static_paths(paths=["images/","images/images","images/prerendered","LUT/","fonts/","assets/"])
 
 # Gradio Blocks Interface
-with gr.Blocks(css_paths="style_20250128.css", title=title, theme='Surn/beeuty',delete_cache=(21600,86400)) as hexaGrid:
+with gr.Blocks(css_paths="style_20250314.css", title=title, theme='Surn/beeuty',delete_cache=(21600,86400)) as hexaGrid:
     with gr.Row():
         gr.Markdown("""
         # HexaGrid Creator
@@ -987,7 +1113,8 @@ with gr.Blocks(css_paths="style_20250128.css", title=title, theme='Surn/beeuty',
                 key="imgInput",
                 image_mode=None,
                 format="PNG",
-                height=512
+                height=450,
+                width=800
             )
             with gr.Accordion("Sketch Pad", open = False, elem_id="sketchpd"):
                 with gr.Row():
@@ -997,23 +1124,21 @@ with gr.Blocks(css_paths="style_20250128.css", title=title, theme='Surn/beeuty',
                         #invert_colors=True,
                         #sources=['upload','canvas'],
                         #tool=['editor','select','color-sketch'],
-                        placeholder="Draw a sketch or upload an image. Currently broken in gradio 5.17.1",
+                        placeholder="Draw a sketch or upload an image.",
                         interactive=True,
                         elem_classes="centered solid imgcontainer",
                         key="imgSketch",
                         image_mode="RGBA",
                         format="PNG",
-                        brush=gr.Brush()
+                        brush=gr.Brush(),
+                        canvas_size=(640,360)
                     )
                 with gr.Row():
                     with gr.Column(scale=1):
-                        sketch_replace_input_image_button = gr.Button(
-                            "Replace Input Image with sketch",
-                            elem_id="sketch_replace_input_image_button",
-                            elem_classes="solid"
-                        )
+                        sketch_replace_input_image_button = gr.Button("Replace Input Image with sketch", elem_id="sketch_replace_input_image_button", elem_classes="solid")
                         sketch_alpha_composite_slider = gr.Slider(0,100,50,0.5, label="Sketch Transparancy", elem_id="alpha_composite_slider")
                         btn_sketch_alpha_composite = gr.Button("Overlay Sketch on Input Image", elem_id="btn_sketchninput", elem_classes="solid")
+                        gr.Markdown("### Do Not add to image if using a fill model")
 
         with gr.Column():
             with gr.Accordion("Hex Coloring and Exclusion", open = False):
@@ -1063,7 +1188,8 @@ with gr.Blocks(css_paths="style_20250128.css", title=title, theme='Surn/beeuty',
                             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"
+                            label="Select a Filter (LUT) file. Populate the LUT File Name field",
+                            examples_per_page = 15,
                         )
                     
                 with gr.Row():
@@ -1093,8 +1219,20 @@ with gr.Blocks(css_paths="style_20250128.css", title=title, theme='Surn/beeuty',
                         value="Cossale/Frames2-Flex.1",
                         elem_classes="solid",
                         elem_id="inference_model",
+                        lines=2,
                         visible=False
                     )
+                    with gr.Accordion("Choose Style Model*", open=False):
+                        lora_gallery = gr.Gallery(
+                            [(open_image(image_path), title) for image_path, title in lora_models],
+                            label="Styles",
+                            allow_preview=False, preview=False ,
+                            columns=2,
+                            elem_id="lora_gallery",
+                            show_share_button=False,
+                            elem_classes="solid", type="filepath", 
+                            object_fit="contain", height="auto", format="png",
+                        )
                     # Update map_options to a Dropdown with choices from constants.PROMPTS keys
                     with gr.Row():
                         with gr.Column():
@@ -1155,7 +1293,8 @@ with gr.Blocks(css_paths="style_20250128.css", title=title, theme='Surn/beeuty',
                             with gr.Row():
                                 with gr.Column(scale=2):
                                     # Gallery from PRE_RENDERED_IMAGES GOES HERE
-                                    prerendered_image_gallery = gr.Gallery(label="Image Gallery", show_label=True, value=build_prerendered_images_by_quality(3,'thumbnail'), elem_id="gallery", elem_classes="solid", type="filepath", columns=[3], rows=[3], preview=False ,object_fit="contain", height="auto", format="png",allow_preview=False)
+                                    prerendered_image_gallery = gr.Gallery(label="Image Gallery", show_label=True, value=build_prerendered_images_by_quality(3,'thumbnail'), elem_id="gallery", 
+                                        elem_classes="solid", type="filepath", columns=[3], rows=[3], preview=False ,object_fit="contain", height="auto", format="png",allow_preview=False)
                                 with gr.Column():
                                     image_guidance_stength = gr.Slider(label="Image Guidance Strength (prompt percentage)", minimum=0, maximum=1.0, value=0.85, step=0.01, interactive=True)
                                     replace_input_image_button = gr.Button(
@@ -1180,14 +1319,14 @@ with gr.Blocks(css_paths="style_20250128.css", title=title, theme='Surn/beeuty',
             y_spacing = gr.Number(label="Adjust Vertical spacing", value=3, 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)
+            add_hex_text = gr.Dropdown(label="Add Text to Hexagons", choices=[None, "Row-Column Coordinates", "Column Letter, Row Number", "Column Number, Row Letter", "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 Text List and Custom Text Color List are repeating 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)
@@ -1230,8 +1369,8 @@ with gr.Blocks(css_paths="style_20250128.css", title=title, theme='Surn/beeuty',
             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",  elem_classes="centered solid imgcontainer", format="PNG", type="filepath", key="ImgBordered",interactive=False, show_download_button=True, show_fullscreen_button=True, show_share_button=True)
-
-    with gr.Accordion("Height Maps and 3D", open=False):
+    accordian_3d = gr.Accordion("Height Maps and 3D", open=False, elem_id="accordian_3d")
+    with accordian_3d:
         with gr.Row():
             depth_image_source = gr.Radio(
                 label="Depth Image Source",
@@ -1249,7 +1388,7 @@ with gr.Blocks(css_paths="style_20250128.css", title=title, theme='Surn/beeuty',
                     video_resolution = gr.Slider(384, 768, value=480, step=32, label="Video Resolution (*danger*)", interactive=True)
                     model_resolution = gr.Slider(512, 2304, value=1024, step=64, label="3D Model Resolution", interactive=True)
         with gr.Row():
-            generate_3d_asset_button = gr.Button("Generate 3D Asset", elem_classes="solid", variant="secondary")
+            generate_3d_asset_button = gr.Button("Generate 3D Asset", elem_classes="solid", variant="secondary", interactive=False)
         with gr.Row():
             depth_output = gr.Image(label="Depth Map", image_mode="L", elem_classes="centered solid imgcontainer", format="PNG", type="filepath", key="DepthOutput",interactive=False, show_download_button=True, show_fullscreen_button=True, show_share_button=True, height=400)
         with gr.Row():
@@ -1310,7 +1449,7 @@ with gr.Blocks(css_paths="style_20250128.css", title=title, theme='Surn/beeuty',
     )
     generate_input_image.click(
         fn=generate_input_image_click,
-        inputs=[input_image,map_options, prompt_textbox, negative_prompt_textbox, model_textbox, randomize_seed, seed_slider, gr.State(False), gr.State(0.5), image_size_ratio],
+        inputs=[input_image,map_options, prompt_textbox, negative_prompt_textbox, model_textbox, randomize_seed, seed_slider, gr.State(False), sketch_image, image_guidance_stength, image_size_ratio],
         outputs=[input_image, seed_slider], scroll_to_output=True
     ).then(
         fn=update_sketch_dimensions,
@@ -1350,6 +1489,14 @@ with gr.Blocks(css_paths="style_20250128.css", title=title, theme='Surn/beeuty',
         inputs=model_options,
         outputs=prompt_notes_label
     )
+    lora_gallery.select(
+        fn=update_selection,
+        inputs=[image_size_ratio],
+        outputs=[model_textbox, model_options, gr.State(selected_index), image_size_ratio, prompt_notes_label]
+    )
+
+    #################### model end ########################################
+
     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],
@@ -1359,7 +1506,7 @@ with gr.Blocks(css_paths="style_20250128.css", title=title, theme='Surn/beeuty',
     #use conditioned_image as the input_image for generate_input_image_click
     generate_input_image_from_gallery.click(
         fn=generate_input_image_click,
-        inputs=[input_image, map_options, prompt_textbox, negative_prompt_textbox, model_textbox,randomize_seed, seed_slider, gr.State(True), image_guidance_stength, image_size_ratio],
+        inputs=[input_image, map_options, prompt_textbox, negative_prompt_textbox, model_textbox,randomize_seed, seed_slider, gr.State(True), sketch_image , image_guidance_stength, image_size_ratio],
         outputs=[input_image, seed_slider], scroll_to_output=True
     ).then(
         fn=update_sketch_dimensions,
@@ -1414,7 +1561,18 @@ with gr.Blocks(css_paths="style_20250128.css", title=title, theme='Surn/beeuty',
     #     inputs=[depth_image_source, resized_width_slider, z_scale_slider, input_image, output_image, overlay_image, bordered_image_output],
     #     outputs=[depth_map_output, model_output, model_file], scroll_to_output=True
     # )
-
+    accordian_3d.expand(
+        fn=load_3d_models,
+        trigger_mode="always_last",
+        outputs=[generate_3d_asset_button],
+        show_api=False
+    )
+    accordian_3d.collapse(
+        fn=unload_3d_models,
+        trigger_mode="always_last",
+        outputs=[generate_3d_asset_button],
+        show_api=False
+    )
     # Chain the buttons
     generate_3d_asset_button.click(
         fn=generate_3d_asset_part1,
@@ -1470,14 +1628,23 @@ if __name__ == "__main__":
 
     #-------------- ------------------------------------------------MODEL INITIALIZATION------------------------------------------------------------#
     # Load models once during module import
-    image_processor = DPTImageProcessor.from_pretrained("Intel/dpt-large")
-    depth_model = DPTForDepthEstimation.from_pretrained("Intel/dpt-large", ignore_mismatched_sizes=True)
-    TRELLIS_PIPELINE = TrellisImageTo3DPipeline.from_pretrained("JeffreyXiang/TRELLIS-image-large")
-    TRELLIS_PIPELINE.cuda()
-    try:
-       TRELLIS_PIPELINE.preprocess_image(Image.fromarray(np.zeros((512, 512, 3), dtype=np.uint8)))    # Preload rembg
-    except:
-        pass
+    dtype = torch.bfloat16
+    device = "cuda" if torch.cuda.is_available() else "cpu"
+    base_model = "black-forest-labs/FLUX.1-dev"
+    good_vae = AutoencoderKL.from_pretrained(base_model, subfolder="vae", torch_dtype=dtype).to(device)
+    #pipe = DiffusionPipeline.from_pretrained(base_model, torch_dtype=dtype, vae=good_vae).to(device)
+    #pipe.enable_model_cpu_offload()
+    #pipe.vae.enable_slicing()
+    #pipe.attn_implementation="flash_attention_2"
+
+    # image_processor = DPTImageProcessor.from_pretrained("Intel/dpt-large")
+    # depth_model = DPTForDepthEstimation.from_pretrained("Intel/dpt-large", ignore_mismatched_sizes=True)
+    # TRELLIS_PIPELINE = TrellisImageTo3DPipeline.from_pretrained("JeffreyXiang/TRELLIS-image-large")
+    # TRELLIS_PIPELINE.to(device)
+    # try:
+    #    TRELLIS_PIPELINE.preprocess_image(Image.fromarray(np.zeros((64, 64, 3), dtype=np.uint8)))    # Preload rembg
+    # except:
+    #     pass
     hexaGrid.queue(default_concurrency_limit=1,max_size=12,api_open=False)
     hexaGrid.launch(allowed_paths=["assets","/","./assets","images","./images", "./images/prerendered", 'e:/TMP'], favicon_path="./assets/favicon.ico", max_file_size="10mb")
 

style_20250128.css → style_20250314.css

@@ -20,9 +20,15 @@
     background-color: rgba(242, 218, 163, 0.62);
 }
 
-.dark .gradio-container.gradio-container-5-20-1 .contain .intro .prose {
+.dark .gradio-container.gradio-container-5-21-0 .contain .intro .prose {
     background-color: rgba(41, 18, 5, 0.38) !important;
 }
+.toast-body.info {
+    background-color: rgba(242, 218, 163, 0.75);
+}
+.dark .toast-body.info {
+    background-color: rgba(128, 128, 128, 0.75);
+}
 
 .small {
     font-size: smaller !important;
@@ -72,26 +78,26 @@ a {
     max-width: 75px;
 }
 
-#gallery .thumbnails {
+#gallery .thumbnails, #lora_gallery .thumbnails {
     flex-direction: column !important;
     display: inline-flex !important;
     flex-wrap: wrap !important;
     position: relative !important;
 }
 
-#gallery caption.caption {
+#gallery caption.caption, #lora_gallery caption.caption {
     flex-direction: row !important;
     display: inline-flex !important;
     flex-wrap: wrap;
     white-space: unset !important;
 }
 
-#gallery .image-button img.with-caption {
+#gallery .image-button img.with-caption, #lora_gallery .image-button img.with-caption {
     object-fit: cover !important;
     object-position: center !important;
 }
 
-#gallery button.preview {
+#gallery button.preview, #lora_gallery button.preview {
     position: relative !important;
 }
 

utils/constants.py

@@ -62,6 +62,8 @@ if not HF_API_TOKEN:
 default_lut_example_img = "./LUT/daisy.jpg"
 MAX_SEED = np.iinfo(np.int32).max
 TARGET_SIZE = (2688,1536)
+BASE_HEIGHT = 576
+SCALE_FACTOR = (8/3)
 TMPDIR = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'tmp')
 os.makedirs(TMPDIR, exist_ok=True)
 
@@ -185,7 +187,7 @@ PRE_RENDERED_MAPS_JSON_LEVELS = {
 
 pre_rendered_maps_paths = [
     map_file['file'].replace("\\", "/")
-    for key, map_file in sorted(
+    for map_name, map_file in sorted(
         PRE_RENDERED_MAPS_JSON_LEVELS.items(),
         key=lambda x: (
             x[1]['quality'],
@@ -199,43 +201,59 @@ pre_rendered_maps_paths_api_file = [f"./gradio_api/file={map_path}" for map_path
 MODELS = [
     "black-forest-labs/FLUX.1-schnell",
     "black-forest-labs/FLUX.1-dev",
-    "ostris/Flex.1-alpha"
+    "ostris/Flex.1-alpha",
+    "black-forest-labs/FLUX.1-Fill-dev"
 ]
 # Available LoRA weights
 LORA_WEIGHTS = [
     "Shakker-Labs/FLUX.1-dev-LoRA-Logo-Design",
+    "Shakker-Labs/FLUX.1-dev-LoRA-Micro-landscape-on-Mobile-Phone",
     "Borcherding/FLUX.1-dev-LoRA-FractalLand-v0.1",
     "Cossale/Frames2-Flex.1",
+    "AlekseyCalvin/HSTcolorFlexAlpha",
     "XLabs-AI/flux-lora-collection/anime_lora.safetensors",
     "XLabs-AI/flux-lora-collection/scenery_lora.safetensors",
     "XLabs-AI/flux-lora-collection/disney_lora.safetensors",
-    "XLabs-AI/flux-RealismLora"
+    "XLabs-AI/flux-RealismLora",
+    "strangerzonehf/Flux-Cute-3D-Kawaii-LoRA",
+    "SebastianBodza/flux_cute3D",
+    "gokaygokay/Flux-Seamless-Texture-LoRA",
+    "gokaygokay/Flux-Game-Assets-LoRA-v2",
 ]
 
 # Map each LoRA weight to its corresponding model
 LORA_TO_MODEL = {
     "Yuanshi/OminiControl": "black-forest-labs/FLUX.1-schnell",
     "Shakker-Labs/FLUX.1-dev-LoRA-Logo-Design": "black-forest-labs/FLUX.1-dev",
+    "Shakker-Labs/FLUX.1-dev-LoRA-Micro-landscape-on-Mobile-Phone": "black-forest-labs/FLUX.1-dev",
     "Borcherding/FLUX.1-dev-LoRA-FractalLand-v0.1": "black-forest-labs/FLUX.1-dev",
     "Cossale/Frames2-Flex.1": "ostris/Flex.1-alpha",
     "AlekseyCalvin/HSTcolorFlexAlpha": "ostris/Flex.1-alpha",
     "XLabs-AI/flux-lora-collection/anime_lora.safetensors":"black-forest-labs/FLUX.1-dev",
     "XLabs-AI/flux-lora-collection/scenery_lora.safetensors":"black-forest-labs/FLUX.1-dev",
     "XLabs-AI/flux-lora-collection/disney_lora.safetensors":"black-forest-labs/FLUX.1-dev",
-    "XLabs-AI/flux-RealismLora":"black-forest-labs/FLUX.1-dev"
+    "XLabs-AI/flux-RealismLora":"black-forest-labs/FLUX.1-dev",
+    "strangerzonehf/Flux-Cute-3D-Kawaii-LoRA":"black-forest-labs/FLUX.1-dev",
+    "SebastianBodza/flux_cute3D":"black-forest-labs/FLUX.1-dev",
+    "gokaygokay/Flux-Seamless-Texture-LoRA":"black-forest-labs/FLUX.1-dev",
+    "gokaygokay/Flux-Game-Assets-LoRA-v2":"black-forest-labs/FLUX.1-dev",
 }
 condition_type = ["depth", "canny", "subject", "coloring", "deblurring", "fill", "redux"]
+
 # Detailed LoRA weight configurations
 LORA_DETAILS = {
     "AlekseyCalvin/HSTcolorFlexAlpha" : [
         {
-            "trigger_words": "(6kStepsCkpt) HST style autochrome photograph",
+            "trigger_words": "(6kStepsCkpt)HST style analog autochrome photo ",
         },
         {
             "weight_name": "HSToricColorFlex_6000steps_LoRAforFluxOrFlex_32dim64alpha.safetensors",
         },
         {
-            "notes": "You should use (6kStepsCkpt) HST style autochrome photograph as trigger words."
+            "notes": "We use (6kStepsCkpt)HST style analog autochrome photo as trigger words."
+        },
+        {
+            "title": "HSToric Color Flex",
         },
         {
             "parameters" :{
@@ -243,7 +261,8 @@ LORA_DETAILS = {
             }
         },
         {
-            "thumbnail": ""
+            "thumbnail": "https://huggingface.co/AlekseyCalvin/HSTcolorFlexAlpha/resolve/main/images/example_gypubjtqx.png",
+            "show_in_gallery": True
         }
         ],
     "XLabs-AI/flux-lora-collection/anime_lora.safetensors":[
@@ -254,6 +273,9 @@ LORA_DETAILS = {
         {
             "trigger_words": "anime,",
         },
+        {
+            "title": "Anime",
+        },
         {
             "notes": "You should use ',anime' as trigger words at the end. "
         },
@@ -263,7 +285,8 @@ LORA_DETAILS = {
             }
         },
         {
-            "thumbnail": ""
+            "thumbnail": "https://github.com/XLabs-AI/x-flux/blob/main/assets/readme/examples/result_14.png?raw=true",
+            "show_in_gallery": True
         }
         ],
     "XLabs-AI/flux-lora-collection/scenery_lora.safetensors":[
@@ -274,6 +297,9 @@ LORA_DETAILS = {
         {
             "trigger_words": "scenery style,",
         },
+        {
+            "title": "Scenery",
+        },
         {
             "notes": "You should use ',scenery style' as trigger words at the end. "
         },
@@ -283,7 +309,8 @@ LORA_DETAILS = {
             }
         },
         {
-            "thumbnail": ""
+            "thumbnail": "https://github.com/XLabs-AI/x-flux/blob/main/assets/readme/examples/result_21.png?raw=true",
+            "show_in_gallery": True
         }
         ],
     "XLabs-AI/flux-lora-collection/disney_lora.safetensors":[
@@ -294,6 +321,9 @@ LORA_DETAILS = {
         {
             "trigger_words": "disney style,",
         },
+        {
+            "title": "Disney Style",
+        },
         {
             "notes": "You should use ',disney style' as trigger words at the end. "
         },
@@ -303,13 +333,17 @@ LORA_DETAILS = {
             }
         },
         {
-            "thumbnail": ""
+            "thumbnail": "https://github.com/XLabs-AI/x-flux/blob/main/assets/readme/examples/result_19.png?raw=true",
+            "show_in_gallery": True
         }
         ],
     "XLabs-AI/flux-RealismLora":[
         {
             "notes": "No trigger words but 8k, Animatrix illustration style, fantasy style, natural photo cinematic should all work "
         },
+        {
+            "title": "Realism",
+        },
         {
             "parameters" :{
                 "guidance_scale": "3.2",
@@ -318,7 +352,8 @@ LORA_DETAILS = {
             }
         },
         {
-            "thumbnail": ""
+            "thumbnail": "https://huggingface.co/VideoAditor/Flux-Lora-Realism/resolve/main/images/feel-the-difference-between-using-flux-with-lora-from-xlab-v0-j0ehybmvxehd1.png",
+            "show_in_gallery": True
         }
         ],
     "Cossale/Frames2-Flex.1": [
@@ -329,6 +364,9 @@ LORA_DETAILS = {
         {
             "trigger_words": "FRM$",
         },
+        {
+            "title": "Frames2-Flex.1",
+        },
         {
             "notes": " FRM$ used as trigger words. "
         },
@@ -338,7 +376,8 @@ LORA_DETAILS = {
             }
         },
         {
-            "thumbnail": ""
+            "thumbnail": "https://huggingface.co/Cossale/Frames2-Flex.1/resolve/main/samples/1737567472380__000005000_2.jpg",
+            "show_in_gallery": True
         }
     ],
     "Yuanshi/OminiControl": [
@@ -350,6 +389,9 @@ LORA_DETAILS = {
             "weight_name": "omini/subject_1024_beta.safetensors",
             "adapter_name": "subject_1024"
         },
+        {
+            "trigger_words": "omini,",
+        },
         {
             "parameters" :{
                 "num_inference_steps": "8",
@@ -360,7 +402,8 @@ LORA_DETAILS = {
             "notes": "Select an Image as a guide."
         },
         {
-            "thumbnail": ""
+            "thumbnail": "",
+            "show_in_gallery": False
         }
     ],
     "Shakker-Labs/FLUX.1-dev-LoRA-Logo-Design": [
@@ -370,6 +413,9 @@ LORA_DETAILS = {
         {
             "trigger_words": "wablogo, logo, Minimalist ",
         },
+        {
+            "title": "Logo Design",
+        },
         {
             "pipe" :{
                 "fuse_lora": {"lora_scale":0.8}
@@ -381,7 +427,38 @@ LORA_DETAILS = {
             }
         },
         {
-            "thumbnail": ""
+            "thumbnail": "https://huggingface.co/Shakker-Labs/FLUX.1-dev-LoRA-Logo-Design/resolve/main/images/73e7db6a33550d05836ce285549de60075d05373c7b0660d631dac33.jpg",
+            "show_in_gallery": True
+        }
+    ],
+    "Shakker-Labs/FLUX.1-dev-LoRA-Micro-landscape-on-Mobile-Phone": [
+        {
+            "notes": "Uses miniature stereoscopic scene as trigger words.."
+        },
+        {
+            "trigger_words": "miniature stereoscopic scene ",
+        },
+        {
+            "title": "Micro Landscape",
+        },
+        {
+            "weight_name": "FLUX-dev-lora-micro-landscape.safetensors",
+        },
+        {
+            "pipe" :{
+                "fuse_lora": {"lora_scale":0.7}
+            }
+        },
+        {
+            "parameters" :{
+                "guidance_scale": "3.5",
+                "num_inference_steps": "24",
+                "scale": "0.72",
+            }
+        },
+        {
+            "thumbnail": "https://huggingface.co/Shakker-Labs/FLUX.1-dev-LoRA-Micro-landscape-on-Mobile-Phone/resolve/main/images/c4f5c765bc8d3d396ed13d65666895ab23ada35c78ca6d91bf814613.jpg",
+            "show_in_gallery": True
         }
     ],
     "Borcherding/FLUX.1-dev-LoRA-FractalLand-v0.1": [
@@ -391,6 +468,9 @@ LORA_DETAILS = {
         {
             "trigger_words": "fractalLand ",
         },
+        {
+            "title": "fractalLand",
+        },
         {
             "parameters" :{
                 "max_sequence_length": "512",
@@ -399,10 +479,134 @@ LORA_DETAILS = {
             }
         },
         {
-            "thumbnail": ""
+            "thumbnail": "https://huggingface.co/Borcherding/FLUX.1-dev-LoRA-FractalLand-v0.1/resolve/main/images/example_e2zoqwftv.png",
+            "show_in_gallery": True
+        }
+    ],
+    "strangerzonehf/Flux-Cute-3D-Kawaii-LoRA": [
+        {
+            "weight_name": "Cute-3d-Kawaii.safetensors",
+        },
+        {
+            "notes": "Uses Cute 3d Kawaii at the start of the prompts "
+        },
+        {
+            "trigger_words": "Cute 3d Kawaii ",
+        },
+        {
+            "title": "Cute 3D Kawaii",
+        },
+        {
+            "parameters" :{
+                "height": "1024"
+            }
+        },
+        {
+            "thumbnail": "https://huggingface.co/strangerzonehf/Flux-Cute-3D-Kawaii-LoRA/resolve/main/images/CK3.png",
+            "show_in_gallery": True
+        }
+    ],
+    "SebastianBodza/flux_cute3D": [
+        {
+            "notes": "Uses NEOCUTE3D at the start of the prompts "
+        },
+        {
+            "trigger_words": "NEOCUTE3D ",
+        },
+        {
+            "title": "Cute 3D",
+        },
+        {
+            "thumbnail": "https://huggingface.co/SebastianBodza/flux_cute3D/resolve/main/images/astronaut.webp",
+            "show_in_gallery": True
+        }
+    ],
+    "gokaygokay/Flux-Seamless-Texture-LoRA": [
+        {
+            "notes": "Uses smlstxtr at the start of the prompts "
+        },
+        {
+            "weight_name": "seamless_texture.safetensors",
+        },
+        {
+            "trigger_words": "smlstxtr ",
+        },
+        {
+            "title": "Seamless Texture",
+        },
+        {
+            "thumbnail": "https://huggingface.co/gokaygokay/Flux-Seamless-Texture-LoRA/resolve/main/images/image3.jpg",
+            "show_in_gallery": True
+        }
+    ],
+    "gokaygokay/Flux-Game-Assets-LoRA-v2": [
+        {
+            "notes": "Uses wbgmsst, white background at the start of the prompts "
+        },
+        {
+            "trigger_words": "wbgmsst, white background ",
+        },
+        {
+            "title": "Game Assets",
+        },
+        {
+            "thumbnail": "https://huggingface.co/gokaygokay/Flux-Game-Assets-LoRA-v2/resolve/main/images/example_y2bqpuphc.png",
+            "show_in_gallery": True
         }
     ]
 }
+
+def sort_loras(sortby):
+    loras = []
+    for key, details in LORA_DETAILS.items():
+        lora_info = {
+            "image": "",
+            "title": "",
+            "repo": key,
+            "weights": "",
+            "trigger_word": "",
+            "notes": ""
+        }
+        for item in details:
+            if "thumbnail" in item:
+                lora_info["image"] = item.get("thumbnail", "")
+            if "weight_name" in item:
+                lora_info["weights"] = item.get("weight_name", "")
+            if "trigger_words" in item:
+                lora_info["trigger_word"] = item.get("trigger_words", "")
+            if "notes" in item:
+                lora_info["notes"] = item.get("notes", "")
+            if "title" in item:
+                lora_info["title"] = item.get("title", "")
+        # Default title to key if not provided
+        if not lora_info["title"]:
+            lora_info["title"] = key
+        # Only add to gallery if there is an image set or any item is flagged "show_in_gallery"
+        if lora_info["image"] or any(item.get("show_in_gallery", False) for item in details):
+            loras.append(lora_info)
+    # Add models from the MODELS list with a default thumbnail
+    for model in MODELS:
+        loras.append({
+            "image": f"images/prerendered/th/"+ model.split("/")[-1]+".png",
+            "title": model.split("/")[-1],
+            "repo": model,
+            "weights": "",
+            "trigger_word": "",
+            "notes": ""
+        })
+    # Sort the loras list by the title attribute
+    loras = sorted(loras, key=lambda x: x[sortby])
+    loras.append({
+        "image": f"images/images/Bee-test-2.png",
+        "title": "Manual Entry",
+        "repo": "Manual Entry",
+        "weights": "",
+        "trigger_word": "",
+        "notes": ""
+    })
+    return loras
+
+LORAS = sort_loras("title")
 # Read the contents of the LUT folder, output to a list
 lut_folder = "./LUT"
 lut_files = [os.path.join(lut_folder, f).replace("\\", "/") for f in os.listdir(lut_folder) if f.endswith(".cube")]

utils/hex_grid.py

@@ -15,6 +15,7 @@ from utils.color_utils import update_color_opacity, parse_hex_color, draw_text_w
 import random  # For random text options
 import utils.constants as constants  # Import constants
 import ast
+from utils.misc import number_to_letter
 
 def calculate_font_size(hex_size, padding=0.6, size_ceil=20, min_font_size=8):
     """
@@ -277,6 +278,10 @@ def generate_hexagon_grid_with_text(hex_size, border_size, input_image=None, ima
                         text = f"{col},{row}"
                     elif add_hex_text_option == "Sequential Numbers":
                         text = f"{hex_index}"
+                    elif add_hex_text_option == "Column Letter, Row Number":
+                        text = f"{number_to_letter(col)},{row}"
+                    elif add_hex_text_option == "Column Number, Row Letter":
+                        text = f"{col},{number_to_letter(row)}"
                     elif text_list:
                         text = text_list[hex_index % len(text_list)]
                     else:

utils/image_utils.py

@@ -102,33 +102,34 @@ def build_prerendered_images(images_list):
 # print(filtered_maps)
 def build_prerendered_images_by_quality(quality_limit, key='file'):
     """
-    Retrieve and sort file paths from PRE_RENDERED_MAPS_JSON_LEVELS where quality is less than or equal to the given limit.
-    The sorting order matches pre_rendered_maps_paths based on quality and a case-insensitive alphanumeric key.
-    
+    Retrieve and sort file paths from PRE_RENDERED_MAPS_JSON_LEVELS where quality is <= quality_limit.
+    Sorts by quality and case-insensitive alphanumeric key.
+
     Args:
-        quality_limit (int): The quality threshold.
-        key (str): The key to extract the file path from each map info (default is 'file').
-    
+        quality_limit (int): Maximum quality threshold
+        key (str): Key to extract file path from map info (default: 'file')
+
     Returns:
-        list: A list of sorted file paths meeting the quality criteria.
-    """
-    # Sort the PRE_RENDERED_MAPS_JSON_LEVELS items by quality and alphanumeric key
-    sorted_maps = sorted(
-        PRE_RENDERED_MAPS_JSON_LEVELS.items(),
-        key=lambda x: (
-            x[1]['quality'],
-            ''.join(char.lower() for char in x[0] if char.isalnum())
-        )
-    )
-    
-    # Filter and extract the file paths that meet the quality limit
-    images_list = [
-        map_info[key].replace("\\", "/")
-        for _, map_info in sorted_maps
-        if map_info['quality'] <= quality_limit
+        tuple: (sorted file paths list, list of corresponding map names)
+    """
+    # Pre-compute lowercase alphanumeric key once per item
+    def get_sort_key(item):
+        name, info = item
+        return (info['quality'], ''.join(c for c in name.lower() if c.isalnum()))
+
+    # Single pass: sort and filter
+    filtered_maps = [
+        (info[key].replace("\\", "/"), name)
+        for name, info in sorted(PRE_RENDERED_MAPS_JSON_LEVELS.items(), key=get_sort_key)
+        if info['quality'] <= quality_limit
     ]
     
-    return build_prerendered_images(images_list)
+    # Split into separate lists efficiently
+    if filtered_maps:
+        #file_paths, map_names = zip(*filtered_maps)
+        #return (build_prerendered_images(file_paths), list(map_names))
+        return [(open_image(file_path), map_name) for file_path, map_name in filtered_maps]
+    return (None,"")
 
 
 def build_encoded_images(images_list):
@@ -615,7 +616,8 @@ def apply_lut_to_image_path(lut_filename: str, image_path: str) -> tuple[Image,
             img, new_image_path = convert_to_rgba_png(image_path)
         else:
             img, new_image_path = convert_to_rgba_png(image_path)
-        delete_image(image_path)
+        if image_path != new_image_path:
+            delete_image(image_path)
     else:
         new_image_path = image_path
     if lut_filename is not None:
@@ -623,7 +625,7 @@ def apply_lut_to_image_path(lut_filename: str, image_path: str) -> tuple[Image,
             img = apply_lut(img, lut_filename)
         except Exception as e:
             print(f"BAD LUT: Error applying LUT {str(e)}.")
-    img.save(new_image_path, format='PNG')
+    img.save(new_image_path.lower(), format='PNG')
     return img, str(new_image_path)
 
 ############################################# RGBA ###########################################################
@@ -838,3 +840,40 @@ def print_json():
     for key, value in PRE_RENDERED_MAPS_JSON_LEVELS.items():
         print(f"    '{key}': {{'file': '{value['file']}', 'thumbnail': '{value['thumbnail']}', 'quality': {value['quality']}}},")
     print("}")
+
+def calculate_optimal_fill_dimensions(image: Image.Image):
+    # Extract the original dimensions
+    original_width, original_height = image.size
+    
+    # Set constants
+    MIN_ASPECT_RATIO = 9 / 16
+    MAX_ASPECT_RATIO = 16 / 9
+    FIXED_DIMENSION = 1024
+
+    # Calculate the aspect ratio of the original image
+    original_aspect_ratio = original_width / original_height
+
+    # Determine which dimension to fix
+    if original_aspect_ratio > 1:  # Wider than tall
+        width = FIXED_DIMENSION
+        height = round(FIXED_DIMENSION / original_aspect_ratio)
+    else:  # Taller than wide
+        height = FIXED_DIMENSION
+        width = round(FIXED_DIMENSION * original_aspect_ratio)
+
+    # Ensure dimensions are multiples of 8
+    width = (width // 8) * 8
+    height = (height // 8) * 8
+
+    # Enforce aspect ratio limits
+    calculated_aspect_ratio = width / height
+    if calculated_aspect_ratio > MAX_ASPECT_RATIO:
+        width = (height * MAX_ASPECT_RATIO // 8) * 8
+    elif calculated_aspect_ratio < MIN_ASPECT_RATIO:
+        height = (width / MIN_ASPECT_RATIO // 8) * 8
+
+    # Ensure width and height remain above the minimum dimensions
+    width = max(width, 576) if width == FIXED_DIMENSION else width
+    height = max(height, 576) if height == FIXED_DIMENSION else height
+
+    return width, height

utils/lora_details.py

@@ -1,16 +1,14 @@
 # utils/lora_details.py
 
 import gradio as gr
-from utils.constants import LORA_DETAILS
-def upd_prompt_notes_by_index(lora_index):
-    """
-    Updates the prompt_notes_label with the notes from LORAS based on index.
+from utils.constants import LORA_DETAILS, MODELS, LORAS
 
-    Args:
-        lora_index (int): The index of the selected LoRA model.
+def get_lora_models():
+    return [(item["image"], item["title"]) for item in LORAS]
 
-    Returns:
-        gr.update: Updated Gradio label component with the notes.
+def upd_prompt_notes_by_index(lora_index):
+    """
+    Updates the prompt notes label based on the selected LoRA model.
     """
     try:
         if LORAS[lora_index]:
@@ -20,7 +18,10 @@ def upd_prompt_notes_by_index(lora_index):
                 trigger_position = LORAS[lora_index].get('trigger_position', "")
                 notes = f"{trigger_position} '{trigger_word}' in prompt"
     except IndexError:
-        notes = "Enter Prompt description of your image, \nusing models without LoRa may take a 30 minutes."
+        notes = (
+            "Enter prompt description of your image. \n"
+            "Using models without LoRA may take 30 minutes."
+        )
     return gr.update(value=notes)
 
 def get_trigger_words_by_index(lora_index):
@@ -138,3 +139,23 @@ def split_prompt_precisely(prompt, max_tokens=77, model="gpt-3.5-turbo"):
     remaining_prompt = encoding.decode(remaining_tokens)
        
     return split_prompt, remaining_prompt
+
+def is_lora_loaded(pipe, adapter_name):
+    """
+    Check if a LoRA weight with the given adapter name is already loaded in the pipeline.
+
+    Args:
+        pipe (FluxPipeline): The pipeline to check.
+        adapter_name (str): The adapter name of the LoRA weight.
+
+    Returns:
+        bool: True if the LoRA weight is loaded, False otherwise.
+    """
+    adapter_list = pipe.get_list_adapters()
+    for component_adapters in adapter_list.values():
+        if adapter_name in component_adapters:
+            return True
+
+    if adapter_name in getattr(pipe, "peft_config", {}):
+        return True
+    return False

utils/misc.py

@@ -108,6 +108,13 @@ def convert_ratio_to_dimensions(ratio, height=512, rotate90=False):
         adjusted_width, adjusted_height = adjusted_height, adjusted_width
     return adjusted_width, adjusted_height
 
+def update_dimensions_on_ratio(aspect_ratio_str, base_height):
+    # Convert aspect_ratio from a string in format "W:H" into numbers and compute new dimensions.
+    width_ratio, height_ratio = map(int, aspect_ratio_str.split(":"))
+    aspect_ratio = width_ratio / height_ratio
+    new_width, new_height = convert_ratio_to_dimensions(aspect_ratio, base_height)
+    return new_width, new_height
+
 def install_torch():    
     print("\nInstalling PyTorch with CUDA support...")
     # Define the package and index URL
@@ -189,4 +196,14 @@ def get_seed(randomize_seed: bool, seed: int) -> int:
     """
     Get the random seed.
     """
-    return np.random.randint(0, MAX_SEED) if randomize_seed else seed
+    return np.random.randint(0, MAX_SEED) if randomize_seed else seed
+
+def number_to_letter(n: int, upper_case: bool = True):
+    result = ''
+    a_char = 97
+    if upper_case:
+        a_char -= 32
+    while abs(n) > 0:
+        n, remainder = divmod(abs(n) - 1, 26)
+        result = chr(a_char + remainder) + result
+    return result