Upload 10 files

.gitattributes

@@ -33,3 +33,5 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+cat.png filter=lfs diff=lfs merge=lfs -text
+snake.png filter=lfs diff=lfs merge=lfs -text

README.md

@@ -1,12 +1,69 @@
 ---
-title: Image Edit
-emoji: 🏃
-colorFrom: blue
-colorTo: indigo
+title: Image Enhancer Pro
+emoji: 📚
+colorFrom: red
+colorTo: purple
 sdk: gradio
-sdk_version: 5.45.0
+sdk_version: 5.33.1
 app_file: app.py
 pinned: false
+license: mit
+short_description: 'Enhance, transform, and analyze images with pro tools — all '
+tags: [mcp-server-track,image_processing]
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# 🖼️ Image Enhancer Pro Suite
+
+A powerful and modular image processing suite featuring essential enhancements, advanced filters, and file utilities — all wrapped in a user-friendly interface with server-side processing and MCP support.
+
+---
+
+## 🚀 Quick Start Guide
+
+### 🔧 Basic Tools
+- **Color Correction**: Adjust brightness, contrast, and saturation
+- **Sharpening**: Enhance image clarity and detail
+- **Noise Reduction**: Remove unwanted noise from images
+- **Upscaling**: Increase resolution using interpolation methods
+- **Auto Enhance**: Automatically optimize overall image quality
+- **Resize / Crop / Rotate / Flip**: Fundamental layout transformations
+- **Grayscale / Blur / Invert**: Visual style and clarity adjustments
+
+### 🧠 Advanced Tools
+- **Edge Detection**: Extract edges using the Canny algorithm
+- **Morphological Operations**: Apply erosion and dilation for shape processing
+- **Contour Analysis**: Detect and analyze object contours
+- **Noise & Effects**: Add creative visual effects and synthetic noise
+
+### 🛠️ Utility Tools
+- **Metadata Extraction**: Read EXIF and other metadata from images
+- **Format Conversion**: Convert images between formats (JPEG, PNG, WebP, etc.)
+- **File Operations**: List, read, and manage image files and folders
+
+### 🧩 Extra Tools
+- **Add Images**: Combine two images by pixel-wise addition
+- **Concatenate Images**: Join two images side-by-side or top-to-bottom (horizontal/vertical)
+
+---
+
+## 💡 Tips for Best Results
+
+- **Image Quality**: Start with high-resolution images for better outputs
+- **Parameter Tuning**: Try different settings for optimal results
+- **Preprocessing First**: Use basic tools before applying advanced effects
+- **Batch Processing**: Automate workflows using utility tools
+- **Format Choice**: Use PNG for lossless quality, JPEG for smaller size
+
+
+## 📞 Support
+
+If you're facing issues, please check:
+
+- ✅ Your image is in a supported format
+- ✅ File permissions allow reading and writing
+- ✅ All required Python modules are installed and accessible
+
+---
+
+Enjoy exploring and enhancing your images! ✨
+

advanced_tools.py

@@ -0,0 +1,272 @@
+import random
+
+import cv2
+import numpy as np
+from pathlib import Path
+from utils import temp_output
+
+def detect_edges(input_path: str, threshold1: int = 100, threshold2: int = 200, output_path: str = None) -> str:
+    """
+    Detect edges using Canny edge detection.
+
+    Args:
+        input_path (str): Input image path.
+        output_path (str): Output path for the edge image.
+        threshold1 (int): Lower threshold for hysteresis.
+        threshold2 (int): Upper threshold for hysteresis.
+
+    Returns:
+        str: Path to the saved edge-detected image.
+    """
+    if output_path is None:
+        output_path = temp_output()
+    img = cv2.imread(str(Path(input_path).expanduser()), cv2.IMREAD_GRAYSCALE)
+    edges = cv2.Canny(img, threshold1, threshold2)
+    cv2.imwrite(str(Path(output_path).expanduser()), edges)
+    return str(output_path)
+
+def apply_erosion(input_path: str, kernel_size: int = 3, iterations: int = 1,output_path: str = None) -> str:
+    """
+    Apply erosion effect to an image.
+
+    Args:
+        input_path (str): Path to the original image.
+        output_path (str): Path to save the eroded image.
+        kernel_size (int): Size of the square kernel.
+        iterations (int): Number of erosion iterations.
+
+    Returns:
+        str: Path to the eroded image.
+    """
+    img = cv2.imread(str(Path(input_path).expanduser()))
+    kernel = np.ones((kernel_size, kernel_size), np.uint8)
+    eroded = cv2.erode(img, kernel, iterations=iterations)
+    cv2.imwrite(str(Path(output_path).expanduser()), eroded)
+    return str(output_path)
+
+def apply_dilation(input_path: str, kernel_size: int = 3, iterations: int = 1,output_path: str = None) -> str:
+    """
+    Apply dilation effect to an image.
+
+    Args:
+        input_path (str): Path to the original image.
+        output_path (str): Path to save the dilated image.
+        kernel_size (int): Size of the square kernel.
+        iterations (int): Number of dilation iterations.
+
+    Returns:
+        str: Path to the dilated image.
+    """
+    if output_path is None:
+        output_path = temp_output()
+
+    img = cv2.imread(str(Path(input_path).expanduser()))
+    kernel = np.ones((kernel_size, kernel_size), np.uint8)
+    dilated = cv2.dilate(img, kernel, iterations=iterations)
+    cv2.imwrite(str(Path(output_path).expanduser()), dilated)
+    return str(output_path)
+
+def blur_advanced(input_path: str, kernel_size: int = 5,output_path: str = None) -> str:
+    """
+    Apply Gaussian blur to an image.
+
+    Args:
+        input_path (str): Path to the source image.
+        output_path (str): Path to save the blurred image.
+        kernel_size (int): Size of the Gaussian kernel (must be odd).
+
+    Returns:
+        str: Path to the blurred image.
+    """
+    if output_path is None:
+        output_path = temp_output()
+    if kernel_size % 2 == 0:
+        raise ValueError("kernel_size must be odd.")
+    img = cv2.imread(str(Path(input_path).expanduser()))
+    blurred = cv2.GaussianBlur(img, (kernel_size, kernel_size), 0)
+    cv2.imwrite(str(Path(output_path).expanduser()), blurred)
+    return str(output_path)
+
+def find_contours(input_path: str, output_path: str) -> str:
+    """
+    Find and draw contours on a binary or grayscale image.
+
+    Args:
+        input_path (str): Input image path.
+        output_path (str): Output path with drawn contours.
+
+    Returns:
+        str: Path to the image with contours drawn.
+    """
+    if output_path is None:
+        output_path = temp_output()
+
+    img = cv2.imread(str(Path(input_path).expanduser()))
+    gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
+    _, thresh = cv2.threshold(gray, 128, 255, cv2.THRESH_BINARY)
+    contours, _ = cv2.findContours(thresh, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+    cv2.drawContours(img, contours, -1, (0, 255, 0), 2)
+    cv2.imwrite(str(Path(output_path).expanduser()), img)
+    return str(output_path)
+
+
+
+def isolate_large_objects(image_path: str, area_threshold: float = 1000.0,output_path: str = None) -> str:
+    """
+    Isolate objects in an image whose area exceeds the given threshold.
+
+    Args:
+        image_path (str): Path to the input image.
+        output_path (str): Path to save the output.
+        area_threshold (float): Minimum area of object to keep.
+
+    Returns:
+        str: Path to the saved image with large objects highlighted.
+    """
+    if output_path is None:
+        output_path = temp_output()
+    image = cv2.imread(str(image_path))
+    gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
+
+    # Use Canny edge detection or thresholding
+    edges = cv2.Canny(gray, 50, 150)
+
+    # Find contours
+    contours, _ = cv2.findContours(edges, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+
+    # Filter by area and draw
+    result = np.zeros_like(image)
+    for cnt in contours:
+        area = cv2.contourArea(cnt)
+        if area > area_threshold:
+            cv2.drawContours(result, [cnt], -1, (0, 255, 0), thickness=cv2.FILLED)
+
+    # Save and return
+    output_path = Path(output_path).expanduser().resolve()
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+    cv2.imwrite(str(output_path), result)
+
+    return str(output_path)
+def extract_bounding_boxes(input_path: str, area_threshold: float = 1000.0) -> list[dict]:
+    """
+    Detect contours and return bounding boxes for large objects.
+
+    Args:
+        input_path (str): Image path.
+        area_threshold (float): Minimum contour area.
+
+    Returns:
+        list of dict: Bounding boxes with keys x, y, width, height.
+    """
+
+    img = cv2.imread(str(Path(input_path).expanduser()))
+    gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
+    edges = cv2.Canny(gray, 50, 150)
+    contours, _ = cv2.findContours(edges, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+
+    boxes = []
+    for cnt in contours:
+        area = cv2.contourArea(cnt)
+        if area > area_threshold:
+            x, y, w, h = cv2.boundingRect(cnt)
+            boxes.append({"x": x, "y": y, "width": w, "height": h})
+
+    return boxes
+
+
+
+def add_noise(input_path: str, r_scale: int = 1, g_scale: int = 1, b_scale: int = 1,output_path: str = None) -> str:
+    """
+    Apply strong random color variation to each RGB channel independently.
+
+    Args:
+        input_path (str): Path to input image.
+        output_path (str): Path to save the result.
+        r_scale (int): Scale (1-5) for Red channel variation.
+        g_scale (int): Scale (1-5) for Green channel variation.
+        b_scale (int): Scale (1-5) for Blue channel variation.
+
+    Returns:
+        str: Path to the modified image.
+    """
+    if output_path is None:
+        output_path = temp_output()
+    # Validate scales
+    for val in [r_scale, g_scale, b_scale]:
+        if not (1 <= val <= 5):
+            raise ValueError("Each channel scale must be between 1 and 5.")
+
+    input_path = Path(input_path).expanduser().resolve()
+    output_path = Path(output_path).expanduser().resolve()
+
+    img = cv2.imread(str(input_path))
+    if img is None:
+        raise FileNotFoundError(f"Image not found: {input_path}")
+
+    height, width, _ = img.shape
+    noise_r = np.random.randint(-51*r_scale, 51*r_scale, size=(height, width), dtype=np.int16)
+    noise_g = np.random.randint(-51*g_scale, 51*g_scale, size=(height, width), dtype=np.int16)
+    noise_b = np.random.randint(-51*b_scale, 51*b_scale, size=(height, width), dtype=np.int16)
+
+    # Split and add noise
+    b, g, r = cv2.split(img.astype(np.int16))
+    r = np.clip(r + noise_r, 0, 255).astype(np.uint8)
+    g = np.clip(g + noise_g, 0, 255).astype(np.uint8)
+    b = np.clip(b + noise_b, 0, 255).astype(np.uint8)
+
+    output_img = cv2.merge([b, g, r])
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+    cv2.imwrite(str(output_path), output_img)
+
+    return str(output_path)
+
+
+
+
+def random_channel_remix(input_path: str ,output_path: str = None) -> str:
+    """
+    Randomly remap RGB channels with random scales:
+    - New R = random([R, G, B]) * random_scale
+    - New G = random([R, G, B]) * random_scale
+    - New B = random([R, G, B]) * random_scale
+
+    Args:
+        input_path (str): Path to input image.
+        output_path (str): Path to save output image.
+
+    Returns:
+        str: Path to saved image.
+    """
+    if output_path is None:
+        output_path = temp_output()
+    input_path = Path(input_path).expanduser().resolve()
+    output_path = Path(output_path).expanduser().resolve()
+
+    img = cv2.imread(str(input_path))
+    if img is None:
+        raise FileNotFoundError(f"Image not found: {input_path}")
+
+    b, g, r = cv2.split(img.astype(np.float32))
+    channels = {'r': r, 'g': g, 'b': b}
+
+    # Randomly assign sources and scales
+    new_r_src = random.choice(['r', 'g', 'b'])
+    new_g_src = random.choice(['r', 'g', 'b'])
+    new_b_src = random.choice(['r', 'g', 'b'])
+
+    r_scale = random.uniform(0.5, 2.0)
+    g_scale = random.uniform(0.5, 2.0)
+    b_scale = random.uniform(0.5, 2.0)
+
+    # Apply remapping
+    new_r = np.clip(channels[new_r_src] * r_scale, 0, 255).astype(np.uint8)
+    new_g = np.clip(channels[new_g_src] * g_scale, 0, 255).astype(np.uint8)
+    new_b = np.clip(channels[new_b_src] * b_scale, 0, 255).astype(np.uint8)
+
+    out_img = cv2.merge([new_b, new_g, new_r])
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+    cv2.imwrite(str(output_path), out_img)
+
+    print(f"R ← {new_r_src.upper()} × {r_scale:.2f}, G ← {new_g_src.upper()} × {g_scale:.2f}, B ← {new_b_src.upper()} × {b_scale:.2f}")
+    return str(output_path)
+

app.py

@@ -0,0 +1,420 @@
+import gradio as gr
+import tempfile
+from pathlib import Path
+import os
+from PIL import Image
+from utils import temp_output
+
+# --- Import all tools ---
+from tools import (
+    apply_color_correction, apply_sharpening, reduce_noise,
+    upscale_resolution, auto_enhance
+)
+from basic_tools import (
+    resize_image, convert_grayscale, image_metadata, convert_format, blur_image,
+    rotate_image, crop_image, thumbnail_image, add_watermark, flip_image,
+    invert_colors, list_images_in_directory, get_image_metadata,
+    apply_random_color_variation, add_images, concat_images
+)
+from advanced_tools import (
+    detect_edges, apply_erosion, apply_dilation, blur_advanced,
+    find_contours, isolate_large_objects, extract_bounding_boxes,
+    add_noise, random_channel_remix
+)
+from utils import create_folder
+
+
+
+
+# --- Create individual interfaces for each tool ---
+def create_basics():
+    """Create interfaces for basic tools"""
+    interfaces = []
+
+    # Color Correction
+    with gr.Tab("Color Correction"):
+        gr.Markdown("**Adjust brightness, contrast, and saturation of your image**")
+        with gr.Row():
+            with gr.Column():
+                cc_img = gr.Image(type="filepath", label="Input Image")
+                cc_brightness = gr.Slider(0.5, 2.0, value=1.0, step=0.05, label="Brightness")
+                cc_contrast = gr.Slider(0.5, 2.0, value=1.0, step=0.05, label="Contrast")
+                cc_saturation = gr.Slider(0.0, 2.0, value=1.0, step=0.05, label="Saturation")
+                cc_output_path = gr.Text(temp_output(), label="Output Image")
+                gr.Examples(
+                    examples=["cat.png","snake.png"],
+                    inputs=[cc_img],
+                    label="Example Images"
+                )
+                cc_btn = gr.Button("Apply Color Correction", variant="primary")
+            with gr.Column():
+                cc_output = gr.Image(label="Enhanced Image")
+        cc_btn.click(apply_color_correction, [cc_img, cc_brightness, cc_contrast, cc_saturation,cc_output_path], cc_output)
+
+    # Sharpening
+    with gr.Tab("Sharpening"):
+        gr.Markdown("**Enhance image clarity and detail**")
+        with gr.Row():
+            with gr.Column():
+                sharp_img = gr.Image(type="filepath", label="Input Image")
+                sharp_strength = gr.Slider(0.5, 2.0, value=1.0, step=0.1, label="Sharpening Strength")
+                sharp_output_path = gr.Text(temp_output(), label="Output Image")
+                gr.Examples(
+                    examples=["cat.png","snake.png"],
+                    inputs=[sharp_img],
+                    label="Example Images"
+                )
+                sharp_btn = gr.Button("Apply Sharpening", variant="primary")
+            with gr.Column():
+                sharp_output = gr.Image(label="Sharpened Image")
+        sharp_btn.click(apply_sharpening, [sharp_img, sharp_strength,sharp_output_path], sharp_output)
+
+    # Noise Reduction
+    with gr.Tab("Noise Reduction"):
+        gr.Markdown("**Remove unwanted noise from your image**")
+        with gr.Row():
+            with gr.Column():
+                noise_img = gr.Image(type="filepath", label="Input Image")
+                noise_strength = gr.Radio(["low", "medium", "high"], value="medium", label="Noise Reduction Strength")
+                noise_output_path = gr.Text(temp_output(), label="Output Image")
+                gr.Examples(
+                    examples=["cat.png","snake.png"],
+                    inputs=[noise_img],
+                    label="Example Images"
+                )
+                noise_btn = gr.Button("Reduce Noise", variant="primary")
+            with gr.Column():
+                noise_output = gr.Image(label="Denoised Image")
+        noise_btn.click(reduce_noise, [noise_img, noise_strength,noise_output_path], noise_output)
+
+    # Upscaling
+    with gr.Tab("Upscaling"):
+        gr.Markdown("**Increase image resolution using advanced interpolation**")
+        with gr.Row():
+            with gr.Column():
+                up_img = gr.Image(type="filepath", label="Input Image")
+                up_scale = gr.Radio([2, 3, 4], value=2, label="Scale Factor")
+                up_method = gr.Dropdown(["nearest", "bilinear", "bicubic", "lanczos"], value="bicubic",
+                                        label="Interpolation Method")
+                up_output_path = gr.Text(temp_output(), label="Output Image")
+                gr.Examples(
+                    examples=["cat.png","snake.png"],
+                    inputs=[up_img],
+                    label="Example Images"
+                )
+                up_btn = gr.Button("Upscale Image", variant="primary")
+            with gr.Column():
+                up_output = gr.Image(label="Upscaled Image")
+        up_btn.click(upscale_resolution, [up_img, up_scale, up_method,up_output_path], up_output)
+
+    # Auto Enhance
+    with gr.Tab("Auto Enhance"):
+        gr.Markdown("**Automatically optimize image quality**")
+        with gr.Row():
+            with gr.Column():
+                auto_img = gr.Image(type="filepath", label="Input Image")
+                auto_output_path = gr.Text(temp_output(), label="Output Image")
+                gr.Examples(
+                    examples=["cat.png","snake.png"],
+                    inputs=[auto_img],
+                    label="Example Images"
+                )
+                auto_btn = gr.Button("Auto Enhance", variant="primary")
+            with gr.Column():
+                auto_output = gr.Image(label="Enhanced Image")
+        auto_btn.click(auto_enhance, [auto_img,auto_output_path], auto_output)
+
+    # Resize
+    with gr.Tab("Resize"):
+        gr.Markdown("**Change image dimensions**")
+        with gr.Row():
+            with gr.Column():
+                resize_img = gr.Image(type="filepath", label="Input Image")
+                resize_width = gr.Number(value=512, label="Width")
+                resize_height = gr.Number(value=512, label="Height")
+                resize_output_path = gr.Text(temp_output(), label="Output Image")
+                gr.Examples(
+                    examples=["cat.png","snake.png"],
+                    inputs=[resize_img],
+                    label="Example Images"
+                )
+                resize_btn = gr.Button("Resize Image", variant="primary")
+            with gr.Column():
+                resize_output = gr.Image(label="Resized Image")
+        resize_btn.click(resize_image, [resize_img, resize_width, resize_height,resize_output_path], resize_output)
+
+    # Grayscale
+    with gr.Tab("Grayscale"):
+        gr.Markdown("**Convert image to grayscale**")
+        with gr.Row():
+            with gr.Column():
+                gray_img = gr.Image(type="filepath", label="Input Image")
+                gray_output_path = gr.Text(temp_output(), label="Output Image")
+                gr.Examples(
+                    examples=["cat.png","snake.png"],
+                    inputs=[gray_img],
+                    label="Example Images"
+                )
+                gray_btn = gr.Button("Convert to Grayscale", variant="primary")
+            with gr.Column():
+                gray_output = gr.Image(label="Grayscale Image")
+        gray_btn.click(convert_grayscale, [gray_img,gray_output_path], gray_output)
+
+    # Additional basic tools (simplified for space)
+    with gr.Tab("More Basic Tools"):
+        gr.Markdown("**Quick access to common image operations**")
+
+        with gr.Accordion("Blur & Effects", open=False):
+            with gr.Row():
+                with gr.Column():
+                    blur_img = gr.Image(type="filepath", label="Input Image")
+                    blur_radius = gr.Slider(0.1, 20.0, value=2.0, step=0.1, label="Blur Radius")
+                    blur_output_path = gr.Text(temp_output(), label="Output Image")
+                    gr.Examples(
+                    examples=["cat.png","snake.png"],
+                    inputs=[blur_img],
+                    label="Example Images"
+                )
+                    blur_btn = gr.Button("Apply Blur")
+                with gr.Column():
+                    blur_output = gr.Image(label="Blurred Image")
+            blur_btn.click(blur_image, [blur_img, blur_radius,blur_output_path], blur_output)
+
+        with gr.Accordion("Rotate & Flip", open=False):
+            with gr.Row():
+                with gr.Column():
+                    rotate_img = gr.Image(type="filepath", label="Input Image")
+                    rotate_angle = gr.Number(value=90.0, label="Rotation Angle")
+                    rotate_output_path = gr.Text(temp_output(), label="Output Image")
+                    gr.Examples(
+                    examples=["cat.png","snake.png"],
+                    inputs=[rotate_img],
+                    label="Example Images"
+                )
+                    rotate_btn = gr.Button("Rotate Image")
+                    flip_mode = gr.Radio(["horizontal", "vertical"], value="horizontal", label="Flip Mode")
+                    flip_output_path = gr.Text(temp_output(), label="Output Image")
+                    
+                    flip_btn = gr.Button("Flip Image")
+                with gr.Column():
+                    rotate_output = gr.Image(label="Rotated/Flipped Image")
+            rotate_btn.click(rotate_image, [rotate_img, rotate_angle,rotate_output_path], rotate_output)
+            flip_btn.click(flip_image, [rotate_img, flip_mode,flip_output_path], rotate_output)
+
+
+def create_advanceds():
+    """Create interfaces for advanced tools"""
+
+    # Edge Detection
+    with gr.Tab("Edge Detection"):
+        gr.Markdown("**Detect edges using Canny edge detection algorithm**")
+        with gr.Row():
+            with gr.Column():
+                edge_img = gr.Image(type="filepath", label="Input Image")
+                edge_t1 = gr.Number(value=100, label="Lower Threshold")
+                edge_t2 = gr.Number(value=200, label="Upper Threshold")
+                edge_output_path = gr.Text(temp_output(), label="Output Image")
+                edge_btn = gr.Button("Detect Edges", variant="primary")
+            with gr.Column():
+                edge_output = gr.Image(label="Edge Detection Result")
+        edge_btn.click(detect_edges, [edge_img, edge_t1, edge_t2,edge_output_path], edge_output)
+
+    # Morphological Operations
+    with gr.Tab("Morphological Ops"):
+        gr.Markdown("**Apply erosion and dilation operations**")
+        with gr.Row():
+            with gr.Column():
+                morph_img = gr.Image(type="filepath", label="Input Image")
+                morph_kernel = gr.Number(value=3, label="Kernel Size")
+                morph_iter = gr.Number(value=1, label="Iterations")
+                erosion_output_path = gr.Text(temp_output(), label="Output Erosion Image")
+                dilation_output_path = gr.Text(temp_output(), label="Output Dilation Image")
+                erosion_btn = gr.Button("Apply Erosion")
+                dilation_btn = gr.Button("Apply Dilation")
+            with gr.Column():
+                morph_output = gr.Image(label="Morphological Result")
+        erosion_btn.click(apply_erosion, [morph_img, morph_kernel, morph_iter,erosion_output_path], morph_output)
+        dilation_btn.click(apply_dilation, [morph_img, morph_kernel, morph_iter,dilation_output_path], morph_output)
+
+    # Contour Analysis
+    with gr.Tab("Contour Analysis"):
+        gr.Markdown("**Find and analyze contours in images**")
+        with gr.Row():
+            with gr.Column():
+                contour_img = gr.Image(type="filepath", label="Input Image")
+                contour_area = gr.Number(value=1000.0, label="Min Area Threshold")
+                contour_output_path = gr.Text(temp_output(), label="Countour Output Image")
+                isolate_output_path = gr.Text(temp_output(), label="Isolate Output Image")
+                contour_btn = gr.Button("Find Contours", variant="primary")
+                isolate_btn = gr.Button("Isolate Large Objects")
+                bbox_btn = gr.Button("Extract Bounding Boxes")
+            with gr.Column():
+                contour_output = gr.Image(label="Contour Result")
+                bbox_output = gr.JSON(label="Bounding Boxes")
+        contour_btn.click(find_contours, [contour_img,contour_output_path], contour_output,)
+        isolate_btn.click(isolate_large_objects, [contour_img, contour_area,isolate_output_path], contour_output)
+        bbox_btn.click(extract_bounding_boxes, [contour_img, contour_area], bbox_output)
+
+    # Noise and Effects
+    with gr.Tab("Noise & Effects"):
+        gr.Markdown("**Add noise and apply special effects**")
+        with gr.Row():
+            with gr.Column():
+                fx_img = gr.Image(type="filepath", label="Input Image")
+                noise_r = gr.Slider(1, 5, value=1, step=1, label="Red Noise Scale")
+                noise_g = gr.Slider(1, 5, value=1, step=1, label="Green Noise Scale")
+                noise_b = gr.Slider(1, 5, value=1, step=1, label="Blue Noise Scale")
+                noise_output_path =gr.Text(temp_output(), label="Noice Output Image")
+                remix_output_path = gr.Text(temp_output(), label="Remix Output Image")
+                noise_btn = gr.Button("Add Noise")
+                remix_btn = gr.Button("Random Channel Remix")
+            with gr.Column():
+                fx_output = gr.Image(label="Effect Result")
+        noise_btn.click(add_noise, [fx_img, noise_r, noise_g, noise_b,noise_output_path], fx_output)
+        remix_btn.click(random_channel_remix, [fx_img,remix_output_path], fx_output)
+
+
+def create_utilitys():
+    """Create interfaces for utility tools"""
+
+    # Metadata Tools
+    with gr.Tab("Metadata"):
+        gr.Markdown("**Extract and view image metadata**")
+        with gr.Row():
+            with gr.Column():
+                meta_img = gr.Image(type="filepath", label="Input Image")
+                meta_btn = gr.Button("Get Metadata (String)", variant="primary")
+                meta_dict_btn = gr.Button("Get Metadata (Dict)")
+            with gr.Column():
+                meta_output = gr.Textbox(label="Metadata String", lines=10)
+                meta_dict_output = gr.JSON(label="Metadata Dictionary")
+        meta_btn.click(image_metadata, [meta_img], meta_output)
+        meta_dict_btn.click(get_image_metadata, [meta_img], meta_dict_output)
+
+    # Format Conversion
+    with gr.Tab("Format Conversion"):
+        gr.Markdown("**Convert between different image formats**")
+        with gr.Row():
+            with gr.Column():
+                fmt_img = gr.Image(type="filepath", label="Input Image")
+                fmt_format = gr.Dropdown(["png", "jpeg", "bmp", "webp", "tiff"], value="png", label="Target Format")
+                fmt_output_path = gr.Text(temp_output(), label="Output Image")
+                fmt_btn = gr.Button("Convert Format", variant="primary")
+            with gr.Column():
+                fmt_output = gr.Image(label="Converted Image")
+        fmt_btn.click(convert_format, [fmt_img, fmt_format,fmt_output_path], fmt_output)
+
+def create_extra_tools():
+    with gr.Tab("Image Merge"):
+        gr.Markdown("**Combine two images by addition or concatenation**")
+
+        with gr.Accordion("Add Images Pixel-wise", open=False):
+            with gr.Row():
+                with gr.Column():
+                    img1_add = gr.Image(type="filepath", label="Image 1")
+                    img2_add = gr.Image(type="filepath", label="Image 2")
+                    add_output_path = gr.Text(temp_output(), label="Output Path")
+                    add_btn = gr.Button("Add Images")
+                with gr.Column():
+                    add_output = gr.Image(label="Added Image")
+
+            add_btn.click(add_images, [img1_add, img2_add, add_output_path], add_output)
+
+        with gr.Accordion("Concatenate Images", open=False):
+            with gr.Row():
+                with gr.Column():
+                    img1_cat = gr.Image(type="filepath", label="Image 1")
+                    img2_cat = gr.Image(type="filepath", label="Image 2")
+                    concat_mode = gr.Radio(["horizontal", "vertical"], value="horizontal", label="Concatenation Mode")
+                    concat_output_path = gr.Text(temp_output(), label="Output Path")
+                    concat_btn = gr.Button("Concatenate")
+                with gr.Column():
+                    concat_output = gr.Image(label="Concatenated Image")
+
+            concat_btn.click(concat_images, [img1_cat, img2_cat, concat_mode, concat_output_path], concat_output)
+
+
+# Create the main application
+with gr.Blocks(theme=gr.themes.Default(), title="Image Enhancer Pro Suite") as demo:
+    # Header
+    gr.Markdown("""
+    # 🖼️ Image Enhancer Pro Suite
+    ### Professional Image Processing Tools - Organized & Easy to Use
+
+    Choose from our comprehensive collection of image processing tools organized by category.
+    """)
+
+    # Main tabbed interface
+    with gr.Tabs():
+        # Basic Tools Tab
+        with gr.TabItem("🔧 Basic Tools", id="basic"):
+            gr.Markdown("## Essential image processing operations")
+            create_basics()
+
+        # Advanced Tools Tab
+        with gr.TabItem("⚡ Advanced Tools", id="advanced"):
+            gr.Markdown("## Computer vision and advanced image analysis")
+            create_advanceds()
+
+        # Utility Tools Tab
+        with gr.TabItem("🛠️ Utilities", id="utilities"):
+            gr.Markdown("## File management and metadata tools")
+            create_utilitys()
+
+        with gr.TabItem("🧩 Extra Tools", id="extra"):
+            gr.Markdown("## Custom tools for image merging and combination")
+            create_extra_tools()
+
+        # Help & Info Tab
+        with gr.TabItem("📚 Help", id="help"):
+            gr.Markdown("""
+            ## 🚀 Quick Start Guide
+
+            ### Basic Tools
+            - **Color Correction**: Adjust brightness, contrast, and saturation
+            - **Sharpening**: Enhance image clarity and detail
+            - **Noise Reduction**: Remove unwanted noise from images
+            - **Upscaling**: Increase resolution with various interpolation methods
+            - **Auto Enhance**: Automatically optimize image quality
+
+            ### Advanced Tools
+            - **Edge Detection**: Find edges using Canny algorithm
+            - **Morphological Operations**: Erosion and dilation for shape analysis
+            - **Contour Analysis**: Find and analyze object contours
+            - **Noise & Effects**: Add artistic effects and noise
+
+            ### Utilities
+            - **Metadata**: Extract EXIF and other image information
+            - **Format Conversion**: Convert between image formats
+            - **File Operations**: Manage directories and files
+
+            ## 💡 Tips for Best Results
+
+            1. **Image Quality**: Upload high-resolution images for best results
+            2. **Parameter Tuning**: Experiment with different parameter values
+            3. **Preprocessing**: Use basic tools before advanced operations
+            4. **Batch Processing**: Use utility tools for managing multiple files
+            5. **Format Choice**: PNG for quality, JPEG for size optimization
+
+            ## 🔧 Technical Notes
+
+            - All processing is done server-side for maximum quality
+            - Temporary files are automatically cleaned up
+            - Supports most common image formats
+            - MCP server integration for extended functionality
+
+            ## 📞 Support
+
+            If you encounter issues, check that:
+            - Your image file is in a supported format
+            - File permissions allow reading/writing
+            - Required tool modules are properly installed
+            """)
+
+# Launch the application
+if __name__ == "__main__":
+    demo.launch(
+        mcp_server=True,
+        allowed_paths=["/tmp", ".", "./output"],
+        show_error=True
+    )

basic_tools.py

@@ -0,0 +1,427 @@
+import os
+from pathlib import Path
+from PIL import Image, ImageFilter, ImageOps, ImageDraw, ImageChops
+import tempfile
+
+def validate_path(p: str) -> Path:
+    path = Path(os.path.expanduser(p)).resolve()
+    if not path.exists():
+        raise FileNotFoundError(f"Path does not exist: {path}")
+    return path
+
+
+def temp_output(suffix=".png"):
+    return tempfile.NamedTemporaryFile(delete=False, suffix=suffix).name
+
+def ensure_path_from_img(img) -> Path:
+    """
+    Ensures that the input is converted to a valid image file path.
+
+    If `img` is a PIL.Image object, it saves it to a temporary file and returns the path.
+    If `img` is already a path (string or Path), it wraps and returns it as a Path.
+
+    Args:
+        img: A PIL.Image or a path string
+
+    Returns:
+        Path to the image file
+    """
+
+    if isinstance(img, Image.Image):
+        temp_input = temp_output()
+        img.save(temp_input)
+        return Path(temp_input)
+    return validate_path(img)
+
+def resize_image(input_path: str, width: int, height: int, output_path: str = None) -> str:
+    """
+    Resize an image and save to a new file.
+
+    Args:
+        input_path (str): Path to source image.
+        output_path (str): Path to save resized image.
+        width (int): New width in pixels.
+        height (int): New height in pixels.
+
+    Returns:
+        str: Path to resized image.
+    """
+    if output_path is None:
+        output_path = temp_output()
+    input_path = validate_path(input_path)
+    output_path = Path(output_path).expanduser().resolve()
+    with Image.open(input_path) as img:
+        img = img.resize((width, height))
+        output_path.parent.mkdir(parents=True, exist_ok=True)
+        img.save(output_path)
+    return str(output_path)
+
+def convert_grayscale(input_path: str, output_path: str = None) -> str:
+    """
+    Convert an image to grayscale.
+
+    Args:
+        input_path (str): Source image path.
+        output_path (str): Path to save grayscale version.
+
+    Returns:
+        str: Path to grayscale image.
+    """
+    if output_path is None:
+        output_path = temp_output()
+    input_path = validate_path(input_path)
+    output_path = Path(output_path).expanduser().resolve()
+    with Image.open(input_path) as img:
+        gray = img.convert("L")
+        output_path.parent.mkdir(parents=True, exist_ok=True)
+        gray.save(output_path)
+    return str(output_path)
+
+def image_metadata(path: str) -> str:
+    """
+    Get image metadata.
+
+    Args:
+        path (str): Image path.
+
+    Returns:
+        str: Format, size, and mode info.
+    """
+    path = validate_path(path)
+    with Image.open(path) as img:
+        return "\n".join([
+            f"Format: {img.format}",
+            f"Size: {img.size}",
+            f"Mode: {img.mode}"
+        ])
+
+def convert_format(input_path: str, format: str, output_path: str = None) -> str:
+    """
+    Convert an image to a new format.
+
+    Args:
+        input_path (str): Source image path.
+        output_path (str): Destination path with extension.
+        format (str): Format (e.g. 'png', 'jpeg').
+
+    Returns:
+        str: Path to converted image.
+    """
+    if output_path is None:
+        output_path = temp_output()
+    input_path = validate_path(input_path)
+    output_path = Path(output_path).expanduser().resolve()
+    with Image.open(input_path) as img:
+        output_path.parent.mkdir(parents=True, exist_ok=True)
+        img.save(output_path, format=format.upper())
+    return str(output_path)
+
+def blur_image(input_path: str, radius: float, output_path: str = None) -> str:
+    """
+    Apply Gaussian blur to an image.
+
+    Args:
+        input_path (str): Image path.
+        output_path (str): Path to save blurred image.
+        radius (float): Blur radius.
+
+    Returns:
+        str: Path to blurred image.
+    """
+    if output_path is None:
+        output_path = temp_output()
+    input_path = validate_path(input_path)
+    output_path = Path(output_path).expanduser().resolve()
+    with Image.open(input_path) as img:
+        img = img.filter(ImageFilter.GaussianBlur(radius))
+        output_path.parent.mkdir(parents=True, exist_ok=True)
+        img.save(output_path)
+    return str(output_path)
+
+def rotate_image(input_path: str, angle: float, output_path: str = None) -> str:
+    """
+    Rotate an image.
+
+    Args:
+        input_path (str): Source path.
+        output_path (str): Destination path.
+        angle (float): Rotation angle in degrees.
+
+    Returns:
+        str: Path to rotated image.
+    """
+    if output_path is None:
+        output_path = temp_output()
+    input_path = validate_path(input_path)
+    output_path = Path(output_path).expanduser().resolve()
+    with Image.open(input_path) as img:
+        img = img.rotate(angle, expand=True)
+        output_path.parent.mkdir(parents=True, exist_ok=True)
+        img.save(output_path)
+    return str(output_path)
+
+def crop_image(input_path: str, left: int, top: int, right: int, bottom: int, output_path: str = None) -> str:
+    """
+    Crop an image.
+
+    Args:
+        input_path (str): Source image.
+        output_path (str): Destination.
+        left, top, right, bottom (int): Crop box coordinates.
+
+    Returns:
+        str: Path to cropped image.
+    """
+    if output_path is None:
+        output_path = temp_output()
+    input_path = validate_path(input_path)
+    output_path = Path(output_path).expanduser().resolve()
+    with Image.open(input_path) as img:
+        img = img.crop((left, top, right, bottom))
+        output_path.parent.mkdir(parents=True, exist_ok=True)
+        img.save(output_path)
+    return str(output_path)
+
+def thumbnail_image(input_path: str, max_width: int, max_height: int, output_path: str = None) -> str:
+    """
+    Resize image while maintaining aspect ratio.
+
+    Args:
+        input_path (str): Source.
+        output_path (str): Target.
+        max_width (int), max_height (int): Constraints.
+
+    Returns:
+        str: Path to thumbnail image.
+    """
+    if output_path is None:
+        output_path = temp_output()
+    input_path = validate_path(input_path)
+    output_path = Path(output_path).expanduser().resolve()
+    with Image.open(input_path) as img:
+        img.thumbnail((max_width, max_height))
+        output_path.parent.mkdir(parents=True, exist_ok=True)
+        img.save(output_path)
+    return str(output_path)
+
+def add_watermark(input_path: str, text: str, x: int, y: int, output_path: str = None) -> str:
+    """
+    Add watermark text.
+
+    Args:
+        input_path (str): Image file.
+        output_path (str): Save path.
+        text (str): Watermark content.
+        x (int), y (int): Position.
+
+    Returns:
+        str: Path to watermarked image.
+    """
+    if output_path is None:
+        output_path = temp_output()
+    input_path = validate_path(input_path)
+    output_path = Path(output_path).expanduser().resolve()
+    with Image.open(input_path).convert("RGBA") as img:
+        watermark = Image.new("RGBA", img.size)
+        draw = ImageDraw.Draw(watermark)
+        draw.text((x, y), text, fill=(255, 255, 255, 128))
+        img = Image.alpha_composite(img, watermark).convert("RGB")
+        output_path.parent.mkdir(parents=True, exist_ok=True)
+        img.save(output_path)
+    return str(output_path)
+
+def flip_image(input_path: str, mode: str, output_path: str = None) -> str:
+    """
+    Flip image horizontally or vertically.
+
+    Args:
+        input_path (str): Source.
+        output_path (str): Destination.
+        mode (str): 'horizontal' or 'vertical'.
+
+    Returns:
+        str: Path to flipped image.
+    """
+    if output_path is None:
+        output_path = temp_output()
+    input_path = validate_path(input_path)
+    output_path = Path(output_path).expanduser().resolve()
+    with Image.open(input_path) as img:
+        if mode == "horizontal":
+            img = img.transpose(Image.FLIP_LEFT_RIGHT)
+        elif mode == "vertical":
+            img = img.transpose(Image.FLIP_TOP_BOTTOM)
+        else:
+            raise ValueError("Invalid mode")
+        output_path.parent.mkdir(parents=True, exist_ok=True)
+        img.save(output_path)
+    return str(output_path)
+
+def invert_colors(input_path: str, output_path: str = None) -> str:
+    """
+    Invert RGB color values.
+
+    Args:
+        input_path (str): Image file.
+        output_path (str): Save location.
+
+    Returns:
+        str: Path to inverted image.
+    """
+    if output_path is None:
+        output_path = temp_output()
+
+    input_path = validate_path(input_path)
+    output_path = Path(output_path).expanduser().resolve()
+    with Image.open(input_path) as img:
+        img = ImageOps.invert(img.convert("RGB"))
+        output_path.parent.mkdir(parents=True, exist_ok=True)
+        img.save(output_path)
+    return str(output_path)
+
+def list_images_in_directory(path: str) -> str:
+    """
+    List image files in a directory.
+
+    Args:
+        path (str): Directory path.
+
+    Returns:
+        str: Newline-separated list of image paths.
+    """
+    dir_path = Path(path).expanduser().resolve()
+    if not dir_path.is_dir():
+        raise NotADirectoryError(f"{dir_path} is not a directory.")
+    exts = {".png", ".jpg", ".jpeg", ".webp", ".bmp", ".gif"}
+    files = [str(p) for p in dir_path.iterdir() if p.suffix.lower() in exts]
+    return "\n".join(files) if files else "No image files found."
+
+def get_image_metadata(path: str) -> dict:
+    """
+    Get metadata from an image.
+
+    Args:
+        path (str): Image path.
+
+    Returns:
+        dict: Metadata fields including format, size, mode.
+    """
+
+    path = validate_path(path)
+    with Image.open(path) as img:
+        return {
+            "path": str(path),
+            "format": img.format,
+            "mode": img.mode,
+            "size": img.size,
+            "width": img.width,
+            "height": img.height,
+            "info": img.info
+        }
+
+import random
+
+def apply_random_color_variation(input_path: str, strength: float = 0.1,output_path: str = None) -> str:
+    """
+    Apply random color variation to an image and save the result.
+
+    Args:
+        input_path (str): Source image path.
+        output_path (str): Target image path.
+        strength (float): Amount of variation per channel (0.0 to 1.0, default = 0.1).
+
+    Returns:
+        str: Path to the color-augmented image.
+    """
+    if output_path is None:
+        output_path = temp_output()
+    input_path = validate_path(input_path)
+    output_path = Path(output_path).expanduser().resolve()
+
+    with Image.open(input_path).convert("RGB") as img:
+        pixels = img.load()
+        for y in range(img.height):
+            for x in range(img.width):
+                r, g, b = pixels[x, y]
+                r = int(min(max(r + random.randint(-int(255 * strength), int(255 * strength)), 0), 255))
+                g = int(min(max(g + random.randint(-int(255 * strength), int(255 * strength)), 0), 255))
+                b = int(min(max(b + random.randint(-int(255 * strength), int(255 * strength)), 0), 255))
+                pixels[x, y] = (r, g, b)
+
+        output_path.parent.mkdir(parents=True, exist_ok=True)
+        img.save(output_path)
+
+    return str(output_path)
+
+
+def add_images(image_path1: str, image_path2: str, output_path: str = None) -> str:
+    """
+    Add two images pixel-wise and save the result.
+
+    Args:
+        image_path1 (str): Path to the first image.
+        image_path2 (str): Path to the second image.
+        output_path (str): Path to save the resulting image.
+
+    Returns:
+        str: Path to the added image.
+    """
+    if output_path is None:
+        output_path = temp_output()
+
+    path1 = validate_path(image_path1)
+    path2 = validate_path(image_path2)
+    output_path = Path(output_path).expanduser().resolve()
+
+    with Image.open(path1).convert("RGB") as img1, Image.open(path2).convert("RGB") as img2:
+        if img1.size != img2.size:
+            raise ValueError("Images must be the same size")
+        result = ImageChops.add(img1, img2, scale=1.0, offset=0)
+        output_path.parent.mkdir(parents=True, exist_ok=True)
+        result.save(output_path)
+
+    return str(output_path)
+from PIL import Image
+from pathlib import Path
+
+def concat_images(image_path1: str, image_path2: str, mode: str = "horizontal", output_path: str = None) -> str:
+    """
+    Concatenate two images either horizontally or vertically.
+
+    Args:
+        image_path1 (str): Path to the first image.
+        image_path2 (str): Path to the second image.
+        output_path (str): Path to save the concatenated image.
+        mode (str): 'horizontal' or 'vertical'.
+
+    Returns:
+        str: Path to the output image.
+    """
+    if output_path is None:
+        output_path = temp_output()
+
+    img1 = Image.open(image_path1).convert("RGB")
+    img2 = Image.open(image_path2).convert("RGB")
+
+    if mode == "horizontal":
+        new_width = img1.width + img2.width
+        new_height = max(img1.height, img2.height)
+        new_img = Image.new("RGB", (new_width, new_height))
+        new_img.paste(img1, (0, 0))
+        new_img.paste(img2, (img1.width, 0))
+    elif mode == "vertical":
+        new_width = max(img1.width, img2.width)
+        new_height = img1.height + img2.height
+        new_img = Image.new("RGB", (new_width, new_height))
+        new_img.paste(img1, (0, 0))
+        new_img.paste(img2, (0, img1.height))
+    else:
+        raise ValueError("Invalid mode. Use 'horizontal' or 'vertical'.")
+
+    output_path = Path(output_path).expanduser().resolve()
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+    new_img.save(output_path)
+    return str(output_path)
+
+
+

gradio_client_app.py

@@ -0,0 +1,13 @@
+from gradio_client import Client, handle_file
+from pathlib import Path
+
+client = Client("ayman3000/Image_enhancer_pro"")
+result = client.predict(
+		input_path=handle_file('cat.png'),
+		brightness=1.3,
+		contrast=1,
+		saturation=1,
+		output_path="/tmp/tmp_5cvuybs.png",
+		api_name="/apply_color_correction"
+)
+print(result)

requirements.txt

@@ -0,0 +1,3 @@
+pillow
+numpy
+opencv-python

tools.py

@@ -0,0 +1,324 @@
+# 📁 File: tools/image_enhancer/tools.py
+
+import os
+import cv2
+import numpy as np
+from PIL import Image, ImageEnhance, ImageFilter
+from utils import validate_path, ensure_path_from_img, temp_output
+
+# === TOOL IMPLEMENTATIONS ===
+
+def apply_color_correction(input_path: str,
+                           brightness: float = 1.0,
+                           contrast: float = 1.0,
+                           saturation: float = 1.0,
+                           output_path: str = None):
+    """
+    Applies color correction to an image including brightness, contrast and saturation adjustments.
+
+    Args:
+        input_path (str): Path to the input image file
+        output_path (str): Path where the corrected image will be saved
+        brightness (float): Brightness factor (1.0 is original, <1.0 darker, >1.0 brighter)
+        contrast (float): Contrast factor (1.0 is original, <1.0 less contrast, >1.0 more contrast)
+        saturation (float): Saturation factor (1.0 is original, <1.0 less saturated, >1.0 more saturated)
+
+    Returns:
+        None: The function saves the output file to the specified path
+
+    Raises:
+        FileNotFoundError: If the input file does not exist
+        ValueError: If the input is not a valid image
+        OSError: If there's an error creating the output directory or writing the file
+    """
+    try:
+        if output_path is None:
+            output_path = temp_output()
+        img = ensure_path_from_img(input_path)
+
+        # Open the image
+        img = Image.open(img)
+
+        # Apply brightness adjustment
+        if brightness != 1.0:
+            enhancer = ImageEnhance.Brightness(img)
+            img = enhancer.enhance(brightness)
+
+        # Apply contrast adjustment
+        if contrast != 1.0:
+            enhancer = ImageEnhance.Contrast(img)
+            img = enhancer.enhance(contrast)
+
+        # Apply saturation adjustment
+        if saturation != 1.0:
+            enhancer = ImageEnhance.Color(img)
+            img = enhancer.enhance(saturation)
+
+        # Ensure the output directory exists
+        os.makedirs(os.path.dirname(output_path), exist_ok=True)
+
+        # Save the result
+        img.save(output_path)
+    except Exception as e:
+        # Re-raise with more context
+        raise type(e)(f"Error in color correction: {str(e)}")
+    return str(output_path)
+
+
+def apply_sharpening(input_path: str, strength: float = 1.0, output_path: str = None)-> str:
+    """
+    Applies sharpening to an image to enhance edges and details.
+
+    Args:
+        input_path (str): Path to the input image file
+        output_path (str): Path where the sharpened image will be saved
+        strength (float): Sharpening strength (1.0 is standard, >1.0 is stronger)
+
+    Returns:
+        output_path (str): Path where the sharpened image will be saved
+
+    Raises:
+        FileNotFoundError: If the input file does not exist
+        ValueError: If the input is not a valid image
+        OSError: If there's an error creating the output directory or writing the file
+    """
+    try:
+        if output_path is None:
+            output_path = temp_output()
+        # Validate input file exists
+        if not os.path.exists(input_path):
+            raise FileNotFoundError(f"Input file not found: {input_path}")
+        img = ensure_path_from_img(input_path)
+
+        # Open the image
+        img = Image.open(img)
+
+        # Apply sharpening
+        if strength <= 1.0:
+            # Use PIL's built-in SHARPEN filter for moderate sharpening
+            sharpened = img.filter(ImageFilter.SHARPEN)
+        else:
+            # For stronger sharpening, use UnsharpMask with adjusted parameters
+            radius = 2.0
+            percent = int(150 * strength)
+            threshold = 3
+            sharpened = img.filter(ImageFilter.UnsharpMask(radius, percent, threshold))
+
+        # Ensure the output directory exists
+        os.makedirs(os.path.dirname(output_path), exist_ok=True)
+
+        # Save the result
+        sharpened.save(output_path)
+    except Exception as e:
+        # Re-raise with more context
+        raise type(e)(f"Error in sharpening: {str(e)}")
+    return str(output_path)
+
+# --- Constants for Denoising Parameters ---
+# These values control the filtering strength.
+# h: Luminance component filter strength. Larger h means more noise removal.
+# hColor: Color component filter strength.
+# templateWindowSize: Should be odd. Recommended: 7.
+# searchWindowSize: Should be odd. Recommended: 21.
+DENOISE_PARAMS = {
+    "low": {
+        "h": 5,
+        "hColor": 5,
+        "templateWindowSize": 7,
+        "searchWindowSize": 21,
+    },
+    "medium": {
+        "h": 10,
+        "hColor": 10,
+        "templateWindowSize": 7,
+        "searchWindowSize": 21,
+    },
+    "high": {
+        "h": 15,
+        "hColor": 15,
+        "templateWindowSize": 7,
+        "searchWindowSize": 21,
+    }
+}
+
+def reduce_noise(input_path: str, strength: str = "medium", output_path: str = None) -> str:
+    """
+    Reduces noise in an image using cv2.fastNlMeansDenoisingColored.
+
+    Args:
+        input_path (str): Path to the input image file.
+        output_path (str): Path where the denoised image will be saved.
+        strength (str): Noise reduction strength ("low", "medium", or "high").
+    Returns:
+    output_path (str): Path where the sharpened image will be saved
+
+    Raises:
+        FileNotFoundError: If the input file does not exist.
+        ValueError: If the strength parameter is invalid or the image cannot be loaded.
+        OSError: If there's an error creating the output directory or writing the file.
+    """
+    if output_path is None:
+        output_path = temp_output()
+    if not os.path.exists(input_path):
+        raise FileNotFoundError(f"Input file not found: {input_path}")
+
+    if strength not in DENOISE_PARAMS:
+        raise ValueError(f"Invalid strength value: {strength}. Must be one of {list(DENOISE_PARAMS.keys())}")
+
+    try:
+        img = cv2.imread(input_path)
+
+        if img is None:
+            # This can happen if the file exists but is corrupted or not a valid image format.
+            raise ValueError(f"Failed to load image from path: {input_path}. The file may be corrupted or in an unsupported format.")
+
+        # Get parameters for the chosen strength
+        params = DENOISE_PARAMS[strength]
+
+        # Apply noise reduction
+        denoised = cv2.fastNlMeansDenoisingColored(
+            img,
+            None,
+            params["h"],
+            params["hColor"],
+            params["templateWindowSize"],
+            params["searchWindowSize"]
+        )
+
+        # Ensure the output directory exists
+        output_dir = os.path.dirname(output_path)
+        if output_dir:
+            os.makedirs(output_dir, exist_ok=True)
+
+        # Save the result
+        success = cv2.imwrite(output_path, denoised)
+        if not success:
+            raise OSError(f"Failed to save the denoised image to {output_path}")
+
+    except (cv2.error, OSError) as e:
+        # Catch specific errors from OpenCV or file system and re-raise
+        # them to provide context without losing the original error.
+        raise OSError(f"An error occurred during image processing or file saving for {input_path}") from e
+    return str(output_path)
+
+def upscale_resolution(input_path: str, scale_factor: int = 2, method: str = "bicubic", output_path: str = None) -> str:
+    """
+    Increases the resolution of an image using various upscaling methods.
+
+    Args:
+        input_path (str): Path to the input image file
+        scale_factor (int): How much to increase resolution (2 = 2x, 3 = 3x, 4 = 4x)
+        method (str): Upscaling method ("nearest", "bilinear", "bicubic", or "lanczos")
+        output_path (str): Path where the upscaled image will be saved
+
+    Returns:
+        output_path (str): Path where the sharpened image will be saved
+
+    Raises:
+        FileNotFoundError: If the input file does not exist
+        ValueError: If the scale_factor or method parameters are invalid
+        OSError: If there's an error creating the output directory or writing the file
+    """
+    try:
+        if output_path is None:
+            output_path = temp_output()
+
+        # Validate input file exists
+        if not os.path.exists(input_path):
+            raise FileNotFoundError(f"Input file not found: {input_path}")
+
+        # Validate scale factor
+        if scale_factor not in [2, 3, 4]:
+            raise ValueError(f"Invalid scale factor: {scale_factor}. Must be 2, 3, or 4")
+
+        # Map method names to PIL resampling filters
+        method_map = {
+            "nearest": Image.NEAREST,
+            "bilinear": Image.BILINEAR,
+            "bicubic": Image.BICUBIC,
+            "lanczos": Image.LANCZOS
+        }
+
+        # Validate method name
+        if method.lower() not in method_map:
+            raise ValueError(f"Invalid method: {method}. Must be one of {list(method_map.keys())}")
+
+        # Use bicubic as default if method is not recognized
+        resampling_filter = method_map.get(method.lower(), Image.BICUBIC)
+
+        # Open the image
+        img = Image.open(input_path)
+
+        # Get original dimensions
+        width, height = img.size
+
+        # Calculate new dimensions
+        new_width = width * scale_factor
+        new_height = height * scale_factor
+
+        # Resize the image
+        upscaled = img.resize((new_width, new_height), resampling_filter)
+
+        # Ensure the output directory exists
+        os.makedirs(os.path.dirname(output_path), exist_ok=True)
+
+        # Save the result
+        upscaled.save(output_path)
+    except Exception as e:
+        # Re-raise with more context
+        raise type(e)(f"Error in upscaling: {str(e)}")
+    return str(output_path)
+
+def auto_enhance(input_path: str, output_path: str = None) -> str:
+    """
+    Automatically enhances an image by applying balanced corrections to
+    brightness, contrast, color, and sharpness.
+
+    Args:
+        input_path (str): Path to the input image file
+        output_path (str): Path where the enhanced image will be saved
+
+    Returns:
+        output_path (str): Path where the sharpened image will be saved
+
+    Raises:
+        FileNotFoundError: If the input file does not exist
+        ValueError: If the input is not a valid image
+        OSError: If there's an error creating the output directory or writing the file
+    """
+    try:
+        if output_path is None:
+            output_path = temp_output()
+        # Validate input file exists
+        if not os.path.exists(input_path):
+            raise FileNotFoundError(f"Input file not found: {input_path}")
+
+        # Open the image
+        img = Image.open(input_path)
+
+        # Auto-enhance: apply a series of balanced enhancements
+        # Step 1: Auto-contrast
+        enhancer = ImageEnhance.Contrast(img)
+        img = enhancer.enhance(1.2)
+
+        # Step 2: Moderate brightness adjustment
+        enhancer = ImageEnhance.Brightness(img)
+        img = enhancer.enhance(1.1)
+
+        # Step 3: Moderate color enhancement
+        enhancer = ImageEnhance.Color(img)
+        img = enhancer.enhance(1.1)
+
+        # Step 4: Moderate sharpening
+        enhancer = ImageEnhance.Sharpness(img)
+        img = enhancer.enhance(1.3)
+
+        # Ensure the output directory exists
+        os.makedirs(os.path.dirname(output_path), exist_ok=True)
+
+        # Save the result
+        img.save(output_path)
+    except Exception as e:
+        # Re-raise with more context
+        raise type(e)(f"Error in auto enhancement: {str(e)}")
+    return str(output_path)

utils.py

@@ -0,0 +1,49 @@
+import os
+from pathlib import Path
+import tempfile
+
+from PIL import Image
+
+
+def create_folder(folder_path: str) -> str:
+    """
+    Create a folder if it doesn't exist.
+
+    Args:
+        folder_path (str): Path to the folder to create.
+
+    Returns:
+        str: Absolute path to the created or existing folder.
+    """
+    path = Path(folder_path).expanduser().resolve()
+    path.mkdir(parents=True, exist_ok=True)
+    return str(path)
+
+def validate_path(p: str) -> Path:
+    path = Path(os.path.expanduser(p)).resolve()
+    if not path.exists():
+        raise FileNotFoundError(f"Path does not exist: {path}")
+    return path
+
+
+def temp_output(suffix=".png"):
+    return tempfile.NamedTemporaryFile(delete=False, suffix=suffix).name
+
+def ensure_path_from_img(img) -> Path:
+    """
+    Ensures that the input is converted to a valid image file path.
+
+    If `img` is a PIL.Image object, it saves it to a temporary file and returns the path.
+    If `img` is already a path (string or Path), it wraps and returns it as a Path.
+
+    Args:
+        img: A PIL.Image or a path string
+
+    Returns:
+        Path to the image file
+    """
+    if isinstance(img, Image.Image):
+        temp_input = temp_output()
+        img.save(temp_input)
+        return Path(temp_input)
+    return validate_path(img)