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):
@@ -759,7 +759,7 @@ def load_3d_models(is_open: bool = True) -> bool:
         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")
+        TRELLIS_PIPELINE = TrellisImageTo3DPipeline.from_pretrained("JeffreyXiang/TRELLIS-image-large").to("cpu")
         try:
             # Preload with a dummy image to finalize initialization
             TRELLIS_PIPELINE.preprocess_image(Image.fromarray(np.zeros((256, 256, 3), dtype=np.uint8)))
@@ -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,21 @@ 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)
+        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)
+                # 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'):
@@ -587,7 +627,7 @@ def convert_rgb_to_rgba_safe(image: Image) -> Image:
     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)    
+    rgba_image.putalpha(alpha)
     return rgba_image
 
 def apply_lut_to_image_path(lut_filename: str, image_path: str) -> tuple[Image, str]:
@@ -602,9 +642,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,14 +674,22 @@ 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')
+    return img, gr.update(value=str(new_image_path))
 
 ############################################# RGBA ###########################################################
 
@@ -659,7 +722,8 @@ def convert_jpg_to_rgba(input_path) -> tuple[Image, str]:
         # 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)
+            output_path = rename_file_to_lowercase_extension(input_path)
+            return Image.open(output_path), str(output_path)
         
         print(f"Converting to PNG: {input_path} is a JPG or JPEG file.")
         
@@ -779,22 +843,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