Bug fixes

app.py

@@ -43,7 +43,7 @@ from utils.misc import (
     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 (
@@ -62,7 +62,8 @@ from utils.image_utils import (
     resize_image_with_aspect_ratio,
     build_prerendered_images_by_quality,
     get_image_from_dict,
-    calculate_optimal_fill_dimensions
+    calculate_optimal_fill_dimensions,
+    save_image_to_temp_png
 )
 
 from utils.hex_grid import (
@@ -717,8 +718,7 @@ def on_input_image_change(image_path):
         gr.Warning("Please upload an Input Image to get started.")
         return None, gr.update()
     img, img_path = convert_to_rgba_png(image_path)
-    with Image.open(img_path) as pil_img:
-        width, height = pil_img.size
+    width, height = img.size
     return [img_path, gr.update(width=width, height=height)]
 
 def update_sketch_dimensions(input_image, sketch_image):
@@ -773,10 +773,12 @@ 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
+        if TRELLIS_PIPELINE:
+            TRELLIS_PIPELINE.to("cpu")
+            del TRELLIS_PIPELINE
+        if depth_model:
+            del image_processor
+            del depth_model
         #torch.cuda.empty_cache()
         #torch.cuda.ipc_collect()
         gc.collect()
@@ -890,7 +892,7 @@ def depth_process_image(image_path, resized_width=800, z_scale=208):
         torch.cuda.ipc_collect()
     return img
 
-def generate_3d_asset_part1(depth_image_source, randomize_seed, seed, input_image, output_image, overlay_image, bordered_image_output, progress=gr.Progress(track_tqdm=True)):
+def generate_3d_asset_part1(depth_image_source, randomize_seed, seed, input_image, output_image, overlay_image, bordered_image_output, req: gr.Request, progress=gr.Progress(track_tqdm=True)):
     # Choose the image based on source
     if depth_image_source == "Input Image":
         image_path = input_image
@@ -912,6 +914,9 @@ def generate_3d_asset_part1(depth_image_source, randomize_seed, seed, input_imag
     # Process the image for depth estimation
     depth_img = depth_process_image(image_path, resized_width=1536, z_scale=336)
     depth_img = resize_image_with_aspect_ratio(depth_img, 1536, 1536)
+    
+    user_dir = os.path.join(constants.TMPDIR, str(req.session_hash))
+    depth_img = save_image_to_temp_png(depth_img, user_dir, f"{output_name}_depth")
 
     return depth_img, image_path, output_name, final_seed
 
@@ -1200,7 +1205,7 @@ with gr.Blocks(css_paths="style_20250314.css", title=title, theme='Surn/beeuty',
                 lut_file.change(get_filename, inputs=[lut_file], outputs=[lut_filename])
                 lut_filename.change(show_lut, inputs=[lut_filename, lut_example_image], outputs=[lut_example_image])
                 apply_lut_button.click(
-                    lambda lut_filename, input_image: gr.Warning("Please upload an Input Image to get started.") if input_image is None else apply_lut_to_image_path(lut_filename, input_image)[0], 
+                    lambda lut_filename, input_image: gr.Warning("Please upload an Input Image to get started.") if input_image is None else apply_lut_to_image_path(lut_filename, input_image)[1], 
                     inputs=[lut_filename, input_image], 
                     outputs=[input_image], 
                     scroll_to_output=True
@@ -1321,7 +1326,7 @@ with gr.Blocks(css_paths="style_20250314.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", "Column Letter, Row Number", "Column Number, Row Letter", "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, "Column-Row Coordinates", "Column(Letter)-Row Coordinates", "Column-Row(Letter) 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)

utils/file_utils.py

@@ -38,7 +38,23 @@ def rename_file_to_lowercase_extension(file_path: str) -> str:
     if ext != new_ext:
         new_filename = name + new_ext
         new_file_path = os.path.join(directory, new_filename)
-        os.rename(file_path, new_file_path)
+        try:
+            os.rename(file_path, new_file_path)
+            print(f"Rename {file_path} to {new_file_path}\n")
+        except Exception as e:
+            print(f"os.rename failed: {e}. Falling back to binary copy operation.")
+            try:
+                # Read the file in binary mode and write it to new_file_path
+                with open(file_path, 'rb') as f:
+                    data = f.read()
+                with open(new_file_path, 'wb') as f:
+                    f.write(data)
+                    print(f"Rename {file_path} to {new_file_path}\n")
+                # Optionally, remove the original file after copying
+                #os.remove(file_path)
+            except Exception as inner_e:
+                print(f"Failed to copy file from {file_path} to {new_file_path}: {inner_e}")
+                raise inner_e
         return new_file_path
     else:
         return file_path

utils/hex_grid.py

@@ -274,13 +274,13 @@ def generate_hexagon_grid_with_text(hex_size, border_size, input_image=None, ima
                 if font_size:
                     font = ImageFont.truetype(font_path, font_size)
                     # Determine the text to draw
-                    if add_hex_text_option == "Row-Column Coordinates":
+                    if add_hex_text_option == "Column-Row Coordinates":
                         text = f"{col},{row}"
                     elif add_hex_text_option == "Sequential Numbers":
                         text = f"{hex_index}"
-                    elif add_hex_text_option == "Column Letter Row Number":
+                    elif add_hex_text_option == "Column(Letter)-Row Coordinates":
                         text = f"{number_to_letter(col)}{row}"
-                    elif add_hex_text_option == "Column Number Row Letter":
+                    elif add_hex_text_option == "Column-Row(Letter) Coordinates":
                         text = f"{col}{number_to_letter(row)}"
                     elif text_list:
                         text = text_list[hex_index % len(text_list)]

utils/image_utils.py

@@ -17,6 +17,44 @@ from utils.color_utils import (
 )
 from utils.file_utils import rename_file_to_lowercase_extension
 
+
+
+
+def save_image_to_temp_png(image_source, user_dir: str = None, file_name: str = None):
+    """
+    Opens an image from a file path, URL, or DataURL and saves it as a PNG in the user's temporary directory.
+        
+    Parameters:
+        image_source (str, dict or PIL.Image.Image): The source of the image to open.
+        
+    Returns:
+        str: The file path of the saved PNG image in the temporary directory.
+    """
+    import tempfile
+    import uuid
+
+    # Open the image using the existing utility function
+    img = open_image(image_source)
+        
+    # Ensure the image is in a format that supports PNG (convert if necessary)
+    if img.mode not in ("RGB", "RGBA"):
+        img = img.convert("RGBA")
+        
+    # Generate a unique filename in the system temporary directory
+    if user_dir is None:
+        user_dir = tempfile.gettempdir()
+
+    if file_name is None:
+        file_name = f"{uuid.uuid4()}.png"
+
+    temp_filepath = os.path.join(user_dir, file_name.lower())
+    os.makedirs(user_dir, exist_ok=True)
+
+    # Save the image as PNG
+    img.save(temp_filepath, format="PNG")
+        
+    return temp_filepath
+
 def get_image_from_dict(image_path):
     if isinstance(image_path, dict) :
         if 'composite' in image_path:
@@ -44,14 +82,16 @@ def open_image(image_path):
     Raises:
         Exception: If there is an error opening the image.
     """
+
     if isinstance(image_path, Image.Image):
         return image_path
-    else:        
-        image_path = rename_file_to_lowercase_extension(image_path)
+    elif isinstance(image_path, dict):
+        image_path, is_dict = get_image_from_dict(image_path)
+
+    image_path = rename_file_to_lowercase_extension(image_path)
 
     import requests
     try:
-        image_path, is_dict = get_image_from_dict(image_path)
         # Strip leading and trailing double quotation marks, if present
         image_path = image_path.strip('"')
         if image_path.startswith('http'):
@@ -488,6 +528,24 @@ def resize_and_crop_image(image: Image, new_width: int = 512, new_height: int =
 
 ##################################################### LUTs ############################################################
 
+class Color1DLUT(ImageFilter.Filter):
+    """Custom filter to apply a 1D LUT to an RGB image."""
+    def __init__(self, table, size):
+        self.table = table
+        self.size = size
+        if size != 256:
+            raise ValueError("Only 1D LUTs with size 256 are supported")
+        # Create a 768-entry LUT (256 for R, G, B) scaled to 0-255
+        lut_r = [int(table[i][0] * 255) for i in range(256)]
+        lut_g = [int(table[i][1] * 255) for i in range(256)]
+        lut_b = [int(table[i][2] * 255) for i in range(256)]
+        self.lut = lut_r + lut_g + lut_b
+
+    def filter(self, image):
+        if image.mode != 'RGB':
+            image = image.convert('RGB')
+        return image.point(self.lut)
+
 def is_3dlut_row(row: List[str]) -> bool:
     """
     Check if one line in the file has exactly 3 numeric values.
@@ -504,8 +562,68 @@ def is_3dlut_row(row: List[str]) -> bool:
     except ValueError:
         return False
 
+def read_lut(path_lut: Union[str, os.PathLike], num_channels: int = 3) -> Union[ImageFilter.Color3DLUT, Color1DLUT]:
+    """
+    Read a LUT from a .cube file and return a filter object.
+
+    Detects whether the file contains a 1D or 3D LUT based on keywords
+    "LUT_1D_SIZE" or "LUT_3D_SIZE". Initially assumes a 3D LUT if no size
+    keyword is specified.
 
-def read_lut(path_lut: Union[str, os.PathLike], num_channels: int = 3) -> ImageFilter.Color3DLUT:
+    Args:
+        path_lut: Path to the LUT file (string or os.PathLike).
+        num_channels: Number of color channels in the LUT (default is 3).
+
+    Returns:
+        ImageFilter.Color3DLUT for 3D LUTs or Color1DLUT for 1D LUTs.
+
+    Raises:
+        FileNotFoundError: If the file does not exist.
+        ValueError: If the LUT data is invalid or size mismatches.
+    """
+    with open(path_lut) as f:
+        lines = f.read().splitlines()
+
+    lut_type = "3D"  # Initially assume 3D LUT
+    size = None
+    table = []
+
+    # Parse the file
+    for line in lines:
+        line = line.strip()
+        if line.startswith("#") or not line:
+            continue  # Skip comments and empty lines
+        parts = line.split()
+        if parts[0] == "LUT_3D_SIZE":
+            size = int(parts[1])
+            lut_type = "3D"
+        elif parts[0] == "LUT_1D_SIZE":
+            size = int(parts[1])
+            lut_type = "1D"
+        elif is_3dlut_row(parts):
+            table.append(tuple(float(val) for val in parts))
+
+    # Process based on LUT type
+    if lut_type == "3D":
+        if size is None:
+            # Calculate size assuming 3D LUT
+            len_table = len(table)
+            if len_table == 0:
+                raise ValueError("No valid LUT data found")
+            size = round(len_table ** (1 / 3))
+            if size ** 3 != len_table:
+                raise ValueError(f"Number of table entries {len_table} is not a perfect cube")
+        elif len(table) != size ** 3:
+            raise ValueError(f"Expected {size**3} entries for 3D LUT, got {len(table)}")
+        return ImageFilter.Color3DLUT(size, table, channels=num_channels)
+    else:  # lut_type == "1D"
+        if size is None:
+            raise ValueError("LUT_1D_SIZE not specified for 1D LUT")
+        if len(table) != size:
+            raise ValueError(f"Expected {size} entries for 1D LUT, got {len(table)}")
+        return Color1DLUT(table, size)
+
+def read_3Dlut(path_lut: Union[str, os.PathLike], num_channels: int = 3) -> ImageFilter.Color3DLUT:
     """
     Read LUT from a raw file.
 
@@ -562,33 +680,33 @@ def show_lut(lut_filename: str, lut_example_image: Image = default_lut_example_i
         lut_example_image = open_image(default_lut_example_img)
     return lut_example_image
 
+def apply_1d_lut(image, lut_file):
+    # Read the 1D LUT
+    with open(lut_file) as f:
+        lines = f.read().splitlines()
+    table = []
+    for line in lines:
+        if not line.startswith(("#", "LUT", "TITLE", "DOMAIN")) and line.strip():
+            values = [float(v) for v in line.split()]
+            table.append(tuple(values))
+    
+    # Convert image to grayscale
+    if image.mode != 'L':
+        image = image.convert('L')
+    img_array = np.array(image) / 255.0  # Normalize to [0, 1]
+    
+    # Map grayscale values to colors
+    lut_size = len(table)
+    indices = (img_array * (lut_size - 1)).astype(int)
+    colors = np.array(table)[indices]
+    
+    # Create RGB image
+    rgb_image = Image.fromarray((colors * 255).astype(np.uint8), mode='RGB')
+    return rgb_image
 
 
-def convert_rgb_to_rgba_safe(image: Image) -> Image:
-    """
-    Converts an RGB image to RGBA by adding an alpha channel.
-    Ensures that the original image remains unaltered.
 
-    Parameters:
-        image (PIL.Image.Image): The RGB image to convert.
 
-    Returns:
-        PIL.Image.Image: The converted RGBA image.
-    """
-    if image.mode != 'RGB':
-        if image.mode == 'RGBA':
-            return image
-        elif image.mode == 'P':
-            # Convert palette image to RGBA
-            image = image.convert('RGB')
-        else:
-            raise ValueError("Unsupported image mode for conversion to RGBA.")
-    # Create a copy of the image to avoid modifying the original
-    rgba_image = image.copy()
-    # Optionally, set a default alpha value (e.g., fully opaque)
-    alpha = Image.new('L', rgba_image.size, 255)  # 255 for full opacity
-    rgba_image.putalpha(alpha)    
-    return rgba_image
 
 def apply_lut_to_image_path(lut_filename: str, image_path: str) -> tuple[Image, str]:
     """
@@ -602,9 +720,24 @@ def apply_lut_to_image_path(lut_filename: str, image_path: str) -> tuple[Image,
     Returns:
         tuple: A tuple containing the PIL Image object with the LUT applied and the new image path as a string.
     """
+    import gradio as gr
+
+    img_lut = None
     if image_path is None:
         raise UserWarning("No image provided.")
         return None, None
+
+    # Split the path into directory and filename
+    directory, file_name = os.path.split(image_path)
+    lut_directory, lut_file_name = os.path.split(lut_filename)
+    
+    # Split the filename into name and extension
+    name, ext = os.path.splitext(file_name)
+    lut_name, lut_ext = os.path.splitext(lut_file_name)
+
+    # Convert the extension to lowercase
+    new_ext = ext.lower()
+
     path = Path(image_path)
     img = open_image(image_path)
     if not ((path.suffix.lower() == '.png' and img.mode == 'RGBA')):
@@ -619,16 +752,50 @@ def apply_lut_to_image_path(lut_filename: str, image_path: str) -> tuple[Image,
         if image_path != new_image_path:
             delete_image(image_path)
     else:
-        new_image_path = image_path
-    if lut_filename is not None:
+        # ensure the file extension is lower_case, otherwise leave as is
+        new_filename = name + new_ext
+        new_image_path = os.path.join(directory, new_filename)
+    # Apply the LUT to the image
+    if (lut_filename is not None and img is not None):
         try:
-            img = apply_lut(img, lut_filename)
+            img_lut = apply_lut(img, lut_filename)
         except Exception as e:
             print(f"BAD LUT: Error applying LUT {str(e)}.")
-    img.save(new_image_path.lower(), format='PNG')
-    return img, str(new_image_path)
+        if img_lut is not None:
+            new_filename = name + "_"+ lut_name + new_ext
+            new_image_path = os.path.join(directory, new_filename)
+            delete_image(image_path)
+            img = img_lut
+    img.save(new_image_path, format='PNG')
+    print(f"Image with LUT saved as {new_image_path}")
+    return img, gr.update(value=str(new_image_path))
 
 ############################################# RGBA ###########################################################
+def convert_rgb_to_rgba_safe(image: Image) -> Image:
+    """
+    Converts an RGB image to RGBA by adding an alpha channel.
+    Ensures that the original image remains unaltered.
+
+    Parameters:
+        image (PIL.Image.Image): The RGB image to convert.
+
+    Returns:
+        PIL.Image.Image: The converted RGBA image.
+    """
+    if image.mode != 'RGB':
+        if image.mode == 'RGBA':
+            return image
+        elif image.mode == 'P':
+            # Convert palette image to RGBA
+            image = image.convert('RGB')
+        else:
+            raise ValueError("Unsupported image mode for conversion to RGBA.")
+    # Create a copy of the image to avoid modifying the original
+    rgba_image = image.copy()
+    # Optionally, set a default alpha value (e.g., fully opaque)
+    alpha = Image.new('L', rgba_image.size, 255)  # 255 for full opacity
+    rgba_image.putalpha(alpha)
+    return rgba_image
 
 # Example usage
 # convert_jpg_to_rgba('input.jpg', 'output.png')
@@ -654,12 +821,15 @@ def convert_jpg_to_rgba(input_path) -> tuple[Image, str]:
 
         # Check if the input file exists
         if not input_path.exists():
-            raise FileNotFoundError(f"The file {input_path} does not exist.")
+            #if file was renamed to lower case, update the input path
+            input_path = output_path
+            if not input_path.exists():
+                raise FileNotFoundError(f"The file {input_path} does not exist.")
         
         # Check file extension first to skip unnecessary processing
         if input_path.suffix.lower() not in ('.jpg', '.jpeg'):
             print(f"Skipping conversion: {input_path} is not a JPG or JPEG file.")
-            return Image.open(input_path), str(output_path)
+            return None, None
         
         print(f"Converting to PNG: {input_path} is a JPG or JPEG file.")
         
@@ -779,22 +949,22 @@ def resize_all_images_in_folder(target_width: int, output_folder: str = "resized
                 with Image.open(file_path) as img:
                     # Convert to RGB if needed (handles RGBA, CMYK, etc.)
                     if img.mode != 'RGB':
-                        img = img.convert('RGB')                    
+                        img = img.convert('RGB')
                     # Calculate target height maintaining aspect ratio
                     original_width, original_height = img.size
                     aspect_ratio = original_height / original_width
-                    target_height = int(target_width * aspect_ratio)                    
+                    target_height = int(target_width * aspect_ratio)
                     # Resize using the reference function
-                    resized_img = resize_image_with_aspect_ratio(img, target_width, target_height)                    
+                    resized_img = resize_image_with_aspect_ratio(img, target_width, target_height)
                     # Create output filename
-                    output_filename = output_path / f"{file_prefix}{file_path.name}"                    
+                    output_filename = output_path / f"{file_prefix}{file_path.name.lower()}"
                     # Save the resized image
-                    resized_img.save(output_filename, quality=95)                    
+                    resized_img.save(output_filename, quality=95)
                 successful += 1
-                print(f"Successfully resized: {file_path.name}")                
+                print(f"Successfully resized: {file_path.name.lower()}")
             except Exception as e:
                 failed += 1
-                print(f"Failed to resize {file_path.name}: {str(e)}")
+                print(f"Failed to resize {file_path.name.lower()}: {str(e)}")
     
     print(f"\nResizing complete. Successfully processed: {successful}, Failed: {failed}")
     return successful, failed