Fix for pngs and add warnings

.gitignore

@@ -164,3 +164,4 @@ cython_debug/
 /src/__pycache__
 /utils/__pycache__
 /__pycache__
+/temp_models

app.py

@@ -1,4 +1,4 @@
-import gradio as gr
+import gradio as gr
 from PIL import Image, ImageDraw, ImageChops, ImageColor
 from haishoku.haishoku import Haishoku
 import os
@@ -298,6 +298,9 @@ with gr.Blocks(css_paths="style_20250128.css", title="HexaGrid Creator", theme='
         </details>
         """, elem_classes="intro")
     with gr.Row():
+        from utils.image_utils import convert_to_rgba_png
+
+        # Existing code
         with gr.Column(scale=2):
             input_image = gr.Image(
                 label="Input Image",
@@ -305,21 +308,36 @@ with gr.Blocks(css_paths="style_20250128.css", title="HexaGrid Creator", theme='
                 interactive=True,
                 elem_classes="centered solid imgcontainer",
                 key="imgInput",
-                image_mode="RGBA",
-                format="PNG"
+                image_mode=None,
+                format="PNG", 
+                show_download_button=True,
             )
+
+        # New code to convert input image to RGBA PNG
+        def on_input_image_change(image_path):
+            if image_path is None:
+                gr.Warning("Please upload an Input Image to get started.")
+                return None
+            img, img_path = convert_to_rgba_png(image_path)
+            return img_path
+
+        input_image.change(
+            fn=on_input_image_change,
+            inputs=[input_image],
+            outputs=[input_image], scroll_to_output=True,
+        )
         with gr.Column():
             with gr.Accordion("Hex Coloring and Exclusion", open = False):
                 with gr.Row():
                     with gr.Column():
                         color_picker = gr.ColorPicker(label="Pick a color to exclude",value="#505050")
                     with gr.Column():
-                            filter_color = gr.Checkbox(label="Filter Excluded Colors from Sampling", value=False,)
-                    exclude_color_button = gr.Button("Exclude Color", elem_id="exlude_color_button", elem_classes="solid")
-                    color_display = gr.DataFrame(label="List of Excluded RGBA Colors", headers=["R", "G", "B", "A"], elem_id="excluded_colors", type="array", value=build_dataframe(excluded_color_list), interactive=True, elem_classes="solid centered")
-                    selected_row = gr.Number(0, label="Selected Row", visible=False)
-                    delete_button = gr.Button("Delete Row", elem_id="delete_exclusion_button", elem_classes="solid")
-                    fill_hex = gr.Checkbox(label="Fill Hex with color from Image", value=True)
+                        filter_color = gr.Checkbox(label="Filter Excluded Colors from Sampling", value=False,)
+                exclude_color_button = gr.Button("Exclude Color", elem_id="exlude_color_button", elem_classes="solid")
+                color_display = gr.DataFrame(label="List of Excluded RGBA Colors", headers=["R", "G", "B", "A"], elem_id="excluded_colors", type="array", value=build_dataframe(excluded_color_list), interactive=True, elem_classes="solid centered")
+                selected_row = gr.Number(0, label="Selected Row", visible=False)
+                delete_button = gr.Button("Delete Row", elem_id="delete_exclusion_button", elem_classes="solid")
+                fill_hex = gr.Checkbox(label="Fill Hex with color from Image", value=True)
             with gr.Accordion("Image Filters", open = False):
                 with gr.Row():
                     with gr.Column():
@@ -364,7 +382,12 @@ with gr.Blocks(css_paths="style_20250128.css", title="HexaGrid Creator", theme='
                     
                 lut_file.change(get_filename, inputs=[lut_file], outputs=[lut_filename])
                 lut_filename.change(show_lut, inputs=[lut_filename, lut_example_image], outputs=[lut_example_image])
-                apply_lut_button.click(apply_lut_to_image_path, inputs=[lut_filename, input_image], outputs=[input_image],scroll_to_output=True)
+                apply_lut_button.click(
+                    lambda lut_filename, input_image: gr.Warning("Please upload an Input Image to get started.") if input_image is None else apply_lut_to_image_path(lut_filename, input_image)[0], 
+                    inputs=[lut_filename, input_image], 
+                    outputs=[input_image], 
+                    scroll_to_output=True
+                )
 
     with gr.Row():
         with gr.Accordion("Generative AI", open = False):
@@ -460,30 +483,29 @@ with gr.Blocks(css_paths="style_20250128.css", title="HexaGrid Creator", theme='
         with gr.Row():
             rotation = gr.Slider(-90, 180, 0.0, 0.1, label="Hexagon Rotation (degree)")
             add_hex_text = gr.Dropdown(label="Add Text to Hexagons", choices=[None, "Row-Column Coordinates", "Sequential Numbers", "Playing Cards Sequential", "Playing Cards Alternate Red and Black", "Custom List"], value=None)
-    with gr.Row():
+        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():
+        with gr.Row():
             hex_text_info = gr.Markdown("""
             ### Text Color uses the Border Color and Border Opacity, unless you use a custom list.
             ### The Custom Text List and Custom Text Color List are comma separated lists.
             ### The custom color list is a comma separated list of hex colors.
             #### Example: "A,2,3,4,5,6,7,8,9,10,J,Q,K", "red,#0000FF,#00FF00,red,#FFFF00,#00FFFF,#FF8000,#FF00FF,#FF0080,#FF8000,#FF0080,lightblue"
             """, elem_id="hex_text_info", visible=False)
-            add_hex_text.change(
-                fn=lambda x: (
-                    gr.update(visible=(x == "Custom List")), 
-                    gr.update(visible=(x == "Custom List")),
-                    gr.update(visible=(x != None))
-                ),
-                inputs=add_hex_text,
-                outputs=[custom_text_list, custom_text_color_list, hex_text_info]
-            )
+        add_hex_text.change(
+        fn=lambda x: (
+            gr.update(visible=(x == "Custom List")), 
+            gr.update(visible=(x == "Custom List")),
+            gr.update(visible=(x != None))
+            ),
+            inputs=add_hex_text,
+            outputs=[custom_text_list, custom_text_color_list, hex_text_info]
+        )
     with gr.Row():
         hex_size = gr.Number(label="Hexagon Size", value=32, minimum=1, maximum=768)
         border_size = gr.Slider(-5,25,value=0,step=1,label="Border Size")
-    with gr.Row():
-        rotation = gr.Slider(-90, 180, 0.0, 0.1, label="deg. Rotation")
+    with gr.Row():        
         background_color = gr.ColorPicker(label="Background Color", value="#000000", interactive=True)
         background_opacity = gr.Slider(0,100,0,1,label="Background Opacity %")
         border_color = gr.ColorPicker(label="Border Color", value="#7b7b7b", interactive=True)
@@ -519,7 +541,7 @@ with gr.Blocks(css_paths="style_20250128.css", title="HexaGrid Creator", theme='
                 depth_image_source = gr.Radio(label="Depth Image Source", choices=["Input Image", "Output Image", "Overlay Image","Image with Margins"], value="Input Image")
         with gr.Row():
             generate_depth_button = gr.Button("Generate Depth Map and 3D Model From Selected Image", elem_classes="solid", variant="secondary")
-    with gr.Row():
+        with gr.Row():
             depth_map_output = gr.Image(label="Depth Map", image_mode="L", elem_classes="centered solid imgcontainer", format="PNG", type="filepath", key="ImgDepth")
             model_output = gr.Model3D(label="3D Model", clear_color=[1.0, 1.0, 1.0, 0.25], key="Img3D", elem_classes="centered solid imgcontainer")
     with gr.Row():
@@ -540,7 +562,13 @@ with gr.Blocks(css_paths="style_20250128.css", title="HexaGrid Creator", theme='
 
     delete_button.click(fn=delete_color, inputs=[selected_row, color_display], outputs=[color_display])
     exclude_color_button.click(fn=add_color, inputs=[color_picker, gr.State(excluded_color_list)], outputs=[color_display, gr.State(excluded_color_list)])
-    hex_button.click(hex_create, inputs=[hex_size, border_size, input_image, start_x, start_y, end_x, end_y, rotation, background_color, background_opacity, border_color, border_opacity, fill_hex, color_display, filter_color, x_spacing, y_spacing, add_hex_text, custom_text_list, custom_text_color_list], outputs=[output_image, overlay_image], scroll_to_output=True)
+    hex_button.click(
+        fn=lambda hex_size, border_size, input_image, start_x, start_y, end_x, end_y, rotation, background_color, background_opacity, border_color, border_opacity, fill_hex, color_display, filter_color, x_spacing, y_spacing, add_hex_text, custom_text_list, custom_text_color_list: 
+            gr.Warning("Please upload an Input Image to get started.") if input_image is None else hex_create(hex_size, border_size, input_image, start_x, start_y, end_x, end_y, rotation, background_color, background_opacity, border_color, border_opacity, fill_hex, color_display, filter_color, x_spacing, y_spacing, add_hex_text, custom_text_list, custom_text_color_list),
+        inputs=[hex_size, border_size, input_image, start_x, start_y, end_x, end_y, rotation, background_color, background_opacity, border_color, border_opacity, fill_hex, color_display, filter_color, x_spacing, y_spacing, add_hex_text, custom_text_list, custom_text_color_list],
+        outputs=[output_image, overlay_image],
+        scroll_to_output=True
+    )
     generate_input_image.click(
         fn=generate_input_image_click,
         inputs=[map_options, prompt_textbox, negative_prompt_textbox, model_textbox, gr.State(False), gr.State(0.5), image_size_ratio],
@@ -567,7 +595,7 @@ with gr.Blocks(css_paths="style_20250128.css", title="HexaGrid Creator", theme='
         outputs=prompt_notes_label
     )
     composite_button.click(
-        fn=change_color,
+        fn=lambda input_image, composite_color, composite_opacity: gr.Warning("Please upload an Input Image to get started.") if input_image is None else change_color(input_image, composite_color, composite_opacity),
         inputs=[input_image, composite_color, composite_opacity],
         outputs=[input_image]
     )

requirements.txt

@@ -13,7 +13,7 @@ huggingface_hub
 # git+https://github.com/huggingface/transformers@v4.48.1#egg=transformers
 transformers==4.48.1
 gradio[oauth]
-Pillow
+Pillow>=11.1.0
 numpy
 requests
 # git+https://github.com/huggingface/diffusers
@@ -34,4 +34,6 @@ pycairo
 cairocffi
 pangocffi
 pangocairocffi
-tensorflow
+tensorflow
+cairosvg
+python-dotenv

utils/constants.py

@@ -1,22 +1,36 @@
-import os
+# utils/constants.py
+# constants.py contains all the constants used in the project such as the default LUT example image, prompts, negative prompts, pre-rendered maps, models, LoRA weights, and more.
+# execptions made for some environmental variables
+import os
+from pathlib import Path
+from dotenv import load_dotenv
+
 #Set the environment variables
-os.environ['TF_ENABLE_ONEDNN_OPTS'] = '0'
 os.environ["PYTORCH_CUDA_ALLOC_CONF"] = "max_split_size_mb:256,expandable_segments:True"
+os.environ['TF_ENABLE_ONEDNN_OPTS'] = '0'
+#os.environ["TF_CPP_MIN_LOG_LEVEL"] = '2'
+os.environ['USE_FLASH_ATTENTION'] = '1'
+#os.environ['XFORMERS_FORCE_DISABLE_TRITON']= '1'
+#os.environ['XFORMERS_FORCE_DISABLE_TORCHSCRIPT']= '1'
+os.environ["CUDA_DEVICE_ORDER"] = "PCI_BUS_ID"
+os.environ["PYTORCH_NVML_BASED_CUDA_CHECK"] = "1"
+os.environ["CUDA_VISIBLE_DEVICES"] = "0,1,2,3"
+
 IS_SHARED_SPACE = "Surn/HexaGrid" in os.environ.get('SPACE_ID', '')
 
+# Load environment variables from .env file
+dotenv_path = Path(__file__).parent.parent / '.env'
+load_dotenv(dotenv_path)
+
 # Set the temporary folder location
 #os.environ['TEMP'] = r'e:\\TMP'
 #os.environ['TMPDIR'] = r'e:\\TMP'
 #os.environ['XDG_CACHE_HOME'] = r'E:\\cache'
-os.environ['USE_FLASH_ATTENTION'] = '1'
-#os.environ['XFORMERS_FORCE_DISABLE_TRITON']= '1'
-os.environ["CUDA_DEVICE_ORDER"] = "PCI_BUS_ID"
-os.environ["PYTORCH_NVML_BASED_CUDA_CHECK"] = "1"
-os.environ["CUDA_VISIBLE_DEVICES"] = "0,1,2,3"
 
-# constants.py contains all the constants used in the project
-#os.environ["HF_TOKEN"] = ""
 HF_API_TOKEN = os.getenv("HF_TOKEN")
+if not HF_API_TOKEN:
+    raise ValueError("HF_TOKEN is not set. Please check your .env file.")
+
 default_lut_example_img = "./LUT/daisy.jpg"
 
 PROMPTS = {

utils/image_utils.py

@@ -1,6 +1,7 @@
 # utils/image_utils.py
 import os
 from io import BytesIO
+import cairosvg
 import base64
 import numpy as np
 #from decimal import ROUND_CEILING
@@ -8,6 +9,7 @@ from PIL import Image, ImageChops, ImageDraw, ImageEnhance, ImageFilter, ImageDr
 from typing import List, Union
 #import numpy as np
 #import math
+from pathlib import Path
 from utils.constants import default_lut_example_img
 from utils.color_utils import (
     detect_color_format,
@@ -18,13 +20,14 @@ from utils.misc import (pause)
 def open_image(image_path):
     """
     Opens an image from a file path or URL, or decodes a DataURL string into an image.
-
+    Supports SVG and ICO by converting them to PNG.
+    
     Parameters:
         image_path (str): The file path, URL, or DataURL string of the image to open.
-
+    
     Returns:
         Image: A PIL Image object of the opened image.
-
+    
     Raises:
         Exception: If there is an error opening the image.
     """
@@ -33,17 +36,32 @@ def open_image(image_path):
         # Strip leading and trailing double quotation marks, if present
         image_path = image_path.strip('"')
         if image_path.startswith('http'):
-            # If the image path is a URL, download the image using requests
             response = requests.get(image_path)
-            img = Image.open(BytesIO(response.content))
+            if image_path.lower().endswith('.svg'):
+                png_data = cairosvg.svg2png(bytestring=response.content)
+                img = Image.open(BytesIO(png_data))
+            elif image_path.lower().endswith('.ico'):
+                img = Image.open(BytesIO(response.content)).convert('RGBA')
+            else:
+                img = Image.open(BytesIO(response.content))
         elif image_path.startswith('data'):
-            # If the image path is a DataURL, decode the base64 string
             encoded_data = image_path.split(',')[1]
             decoded_data = base64.b64decode(encoded_data)
-            img = Image.open(BytesIO(decoded_data))
+            if image_path.lower().endswith('.svg'):
+                png_data = cairosvg.svg2png(bytestring=decoded_data)
+                img = Image.open(BytesIO(png_data))
+            elif image_path.lower().endswith('.ico'):
+                img = Image.open(BytesIO(decoded_data)).convert('RGBA')
+            else:
+                img = Image.open(BytesIO(decoded_data))
         else:
-            # Assume that the image path is a file path
-            img = Image.open(image_path)
+            if image_path.lower().endswith('.svg'):
+                png_data = cairosvg.svg2png(url=image_path)
+                img = Image.open(BytesIO(png_data))
+            elif image_path.lower().endswith('.ico'):
+                img = Image.open(image_path).convert('RGBA')
+            else:
+                img = Image.open(image_path)
     except Exception as e:
         raise Exception(f'Error opening image: {e}')
     return img
@@ -75,15 +93,16 @@ def build_encoded_images(images_list):
 def image_to_base64(image):
     """
     Encodes an image to a base64 string.
-
+    Supports ICO files by converting them to PNG with RGBA channels.
+    
     Parameters:
         image (str or PIL.Image.Image): The file path, URL, DataURL string, or PIL Image object of the image to encode.
-
+    
     Returns:
         str: A base64-encoded string of the image.
     """
     buffered = BytesIO()
-    if type(image) is str:
+    if isinstance(image, str):
         image = open_image(image)
     image.save(buffered, format="PNG")
     return "data:image/png;base64," + base64.b64encode(buffered.getvalue()).decode()
@@ -449,11 +468,9 @@ def read_lut(path_lut: Union[str, os.PathLike], num_channels: int = 3) -> ImageF
     """
     with open(path_lut) as f:
         lut_raw = f.read().splitlines()
-
     size = round(len(lut_raw) ** (1 / 3))
     row2val = lambda row: tuple([float(val) for val in row.split(" ")])
     lut_table = [row2val(row) for row in lut_raw if is_3dlut_row(row.split(" "))]
-
     return ImageFilter.Color3DLUT(size, lut_table, num_channels)
 
 def apply_lut(img: Image, lut_path: str = "", lut: ImageFilter.Color3DLUT = None) -> Image:
@@ -477,7 +494,6 @@ def apply_lut(img: Image, lut_path: str = "", lut: ImageFilter.Color3DLUT = None
         if lut_path == "":
             raise ValueError("Either lut_path or lut argument must be provided.")
         lut = read_lut(lut_path)
-
     return img.filter(lut)
 
 def show_lut(lut_filename: str, lut_example_image: Image = default_lut_example_img) -> Image:
@@ -490,6 +506,8 @@ 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 convert_rgb_to_rgba_safe(image: Image) -> Image:
     """
     Converts an RGB image to RGBA by adding an alpha channel.
@@ -509,70 +527,162 @@ def convert_rgb_to_rgba_safe(image: Image) -> Image:
             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)
-    
+    rgba_image.putalpha(alpha)    
     return rgba_image
 
-def apply_lut_to_image_path(lut_filename: str, image_path: str) -> Image:
+def apply_lut_to_image_path(lut_filename: str, image_path: str) -> tuple[Image, str]:
     """
     Apply a LUT to an image and return the result.
-
+    Supports ICO files by converting them to PNG with RGBA channels.
+    
     Args:
         lut_filename: A string representing the path to the LUT file.
         image_path: A string representing the path to the input image.
-
+    
     Returns:
-        A PIL Image object with the LUT applied.
+        tuple: A tuple containing the PIL Image object with the LUT applied and the new image path as a string.
     """
+    if image_path is None:
+        raise UserWarning("No image provided.")
+        return None, None
+    path = Path(image_path)
     img = open_image(image_path)
-    # Handle specific file formats by converting to appropriate modes
-    if image_path.lower().endswith(('.gif', '.webp')):
-        # Convert to RGBA to preserve transparency
-        img = img.convert('RGBA')
-    elif image_path.lower().endswith(('.jpg', '.jpeg')):
-        # Convert to RGB since JPEG doesn't support transparency
-        img = convert_rgb_to_rgba_safe(img)
-    
-    # For other formats like PNG, retain the existing mode
-    # Apply the LUT if provided
+    if not ((path.suffix.lower() == '.png' and img.mode == 'RGBA')):
+        if image_path.lower().endswith(('.jpg', '.jpeg')):
+            img, new_image_path = convert_jpg_to_rgba(path)
+        elif image_path.lower().endswith('.ico'):
+            img, new_image_path = convert_to_rgba_png(image_path)
+        elif image_path.lower().endswith(('.gif', '.webp')):
+            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)
+    else:
+        new_image_path = image_path
     if lut_filename is not None:
         try:
             img = apply_lut(img, lut_filename)
         except Exception as e:
             print(f"BAD LUT: Error applying LUT {str(e)}.")
-    return img
+    img.save(new_image_path, format='PNG')
+    return img, str(new_image_path)
 
+############################################# RGBA ###########################################################
 
-def convert_to_rgba_png(file_path: str) -> None:
+# Example usage
+# convert_jpg_to_rgba('input.jpg', 'output.png')
+def convert_jpg_to_rgba(input_path) -> tuple[Image, str]:
     """
-    Converts an image to RGBA PNG format and saves it with the same base name and a .png extension.
+    Convert a JPG image to RGBA format and save it as a PNG.
 
     Args:
-        file_path (str): The path to the input image file.
+    input_path (str or Path): Path to the input JPG image file.
 
     Raises:
-        ValueError: If the input file extension is not a supported image format.
-        Exception: If there is an error during the conversion or saving process.
+    FileNotFoundError: If the input file does not exist.
+    ValueError: If the input file is not a JPG.
+    OSError: If there's an error reading or writing the file.
+
+    Returns:
+    tuple: A tuple containing the RGBA image and the output path as a string.
     """
     try:
-        # Open the original image
-        img = open_image(file_path)
+        # Convert input_path to Path object if it's a string
+        input_path = Path(input_path)
+        output_path = input_path.with_suffix('.png')
+
+        # Check if the input file exists
+        if not input_path.exists():
+            raise FileNotFoundError(f"The file {input_path} does not exist.")
         
-        # Convert the image to RGBA
-        rgba_img = convert_rgb_to_rgba_safe(img)        
-        # Generate the new file name with .png extension
-        base_name = os.path.splitext(file_path)[0]
-        new_file_path = f"{base_name}.png"        
-        # Save the RGBA image as PNG
-        rgba_img.save(new_file_path, format='PNG')        
-        print(f"Image saved as {new_file_path}")        
+        # 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 None, str(output_path)
+        
+        print(f"Converting to PNG: {input_path} is a JPG or JPEG file.")
+        
+        # Open the image file
+        with Image.open(input_path) as img:
+            # Convert the image to RGBA mode
+            rgba_img = img.convert('RGBA')
+            
+            # Ensure the directory exists for the output file
+            output_path.parent.mkdir(parents=True, exist_ok=True)
+            
+            # Save the image with RGBA mode as PNG
+            rgba_img.save(output_path)
+    
+    except FileNotFoundError as e:
+        print(f"Error: {e}")
+    except ValueError as e:
+        print(f"Error: {e}")
+    except OSError as e:
+        print(f"Error: An OS error occurred while processing the image - {e}")
+    except Exception as e:
+        print(f"An unexpected error occurred: {e}")
+    return rgba_img, str(output_path)
+
+
+def convert_to_rgba_png(file_path: str) -> tuple[Image, str]:
+    """
+    Converts an image to RGBA PNG format and saves it with the same base name and a .png extension.
+    Supports ICO files.
+    
+    Args:
+        file_path (str): The path to the input image file.
+    
+    Returns:
+        tuple: A tuple containing the RGBA image and the new file path as a string.
+    """
+    new_file_path = None
+    rgba_img = None
+    img = None
+    if file_path is None:
+        raise UserWarning("No image provided.")
+        return None, None
+    try:
+        img = open_image(file_path)
+        print(f"Opened image: {file_path}\n")
+        # Handle ICO files
+        if file_path.lower().endswith('.ico'):
+            rgba_img = img.convert('RGBA')
+            new_file_path = Path(file_path).with_suffix('.png')
+            rgba_img.save(new_file_path, format='PNG')
+            print(f"Converted ICO to PNG: {new_file_path}")
+        else:
+            rgba_img, new_file_path = convert_jpg_to_rgba(file_path)
+            if rgba_img is None:
+                rgba_img = convert_rgb_to_rgba_safe(img)
+                new_file_path = Path(file_path).with_suffix('.png')
+                rgba_img.save(new_file_path, format='PNG')
+                print(f"Image saved as {new_file_path}")
     except ValueError as ve:
         print(f"ValueError: {ve}")
     except Exception as e:
-        print(f"Error converting image: {e}")
+        print(f"Error converting image: {e}")
+    return rgba_img if rgba_img else img, str(new_file_path)
+
+def delete_image(file_path: str) -> None:
+    """
+    Deletes the specified image file.
+
+    Parameters:
+        file_path (str): The path to the image file to delete.
+
+    Raises:
+        FileNotFoundError: If the file does not exist.
+        Exception: If there is an error deleting the file.
+    """
+    try:
+        path = Path(file_path)
+        path.unlink()
+        print(f"Deleted original image: {file_path}")
+    except FileNotFoundError:
+        print(f"File not found: {file_path}")
+    except Exception as e:
+        print(f"Error deleting image: {e}")