Implement initial project structure and setup

PINOKIO_GUIDE.md

@@ -0,0 +1,77 @@
+# Pinokio Deployment Guide for PortraitPerfectAI
+
+This guide explains how to deploy the AI-Powered Facial & Body Feature Editor application using Pinokio for local hosting.
+
+## What is Pinokio?
+
+Pinokio is a browser-based platform that allows you to install, run, and manage AI applications locally on your computer. It provides a simple interface for installing and launching applications without dealing with complex command-line operations.
+
+## Prerequisites
+
+- [Pinokio](https://pinokio.computer/) installed on your computer
+- A computer with sufficient resources to run AI applications:
+  - At least 8GB RAM (16GB recommended)
+  - At least 10GB free disk space
+  - NVIDIA GPU with CUDA support (optional but recommended for better performance)
+
+## Installation Steps
+
+1. **Download the PortraitPerfectAI Pinokio Package**
+   - Extract the ZIP file to a location of your choice
+
+2. **Open Pinokio Browser**
+   - Launch the Pinokio application on your computer
+
+3. **Add the Application to Pinokio**
+   - In Pinokio, click on the "+" button to add a new application
+   - Navigate to the folder where you extracted the PortraitPerfectAI files
+   - Select the folder and click "Open"
+
+4. **Install the Application**
+   - Once added, you'll see "PortraitPerfectAI" in your Pinokio dashboard
+   - Click on the application
+   - Click the "Install" button
+   - Wait for the installation to complete (this may take several minutes as it installs Python dependencies)
+
+5. **Launch the Application**
+   - After installation is complete, click the "Launch" button
+   - The application will start and open in your default web browser
+
+## Using the Application
+
+Once launched, you can:
+- Upload images for editing
+- Select facial and body features to modify
+- Adjust settings using sliders and dropdowns
+- Apply AI-powered edits to your images
+- Download the edited results
+
+## Troubleshooting
+
+If you encounter any issues:
+
+1. **Installation Fails**
+   - Ensure you have a stable internet connection
+   - Check that you have sufficient disk space
+   - Try restarting Pinokio and attempting installation again
+
+2. **Application Won't Launch**
+   - Check the Pinokio logs for any error messages
+   - Ensure Python is properly installed on your system
+   - Try reinstalling the application
+
+3. **Slow Performance**
+   - If you don't have a GPU, processing will be slower
+   - Try reducing the image size before uploading
+   - Adjust the processing parameters to lower values
+
+## Technical Details
+
+The Pinokio package includes:
+- `install.json` - Defines the installation process
+- `run.json` - Defines how to run the application
+- `pinokio.js` - Contains metadata and menu configuration
+- `app.py` - The main application file
+- Supporting modules in the `models/` and `utils/` directories
+
+The application uses a Python virtual environment to isolate dependencies and ensure compatibility across different systems.

app.py

@@ -0,0 +1,197 @@
+import os
+import gradio as gr
+import torch
+from PIL import Image
+import numpy as np
+from models.ledits_model import LEDITSModel
+from utils.image_processing import preprocess_image, postprocess_image
+from utils.feature_detection import detect_features, create_mask
+
+# Initialize models
+def initialize_models():
+    ledits_model = LEDITSModel()
+    return ledits_model
+
+# Global variables
+FEATURE_TYPES = ["Eyes", "Nose", "Lips", "Face Shape", "Hair", "Body"]
+MODIFICATION_PRESETS = {
+    "Eyes": ["Larger", "Smaller", "Change Color", "Change Shape"],
+    "Nose": ["Refine", "Reshape", "Resize"],
+    "Lips": ["Fuller", "Thinner", "Change Color"],
+    "Face Shape": ["Slim", "Round", "Define Jawline", "Soften Features"],
+    "Hair": ["Change Color", "Change Style", "Add Volume"],
+    "Body": ["Slim", "Athletic", "Curvy", "Muscular"]
+}
+
+# Main editing function
+def edit_image(image, feature_type, modification_type, intensity, 
+               custom_prompt="", use_custom_prompt=False):
+    if image is None:
+        return None, "Please upload an image first."
+    
+    try:
+        # Convert to numpy array if needed
+        if isinstance(image, Image.Image):
+            image_np = np.array(image)
+        else:
+            image_np = image
+            
+        # Preprocess image
+        processed_image = preprocess_image(image_np)
+        
+        # Detect features and create mask
+        features = detect_features(processed_image)
+        mask = create_mask(processed_image, feature_type, features)
+        
+        # Get model
+        ledits_model = initialize_models()
+        
+        # Prepare prompt
+        if use_custom_prompt and custom_prompt:
+            prompt = custom_prompt
+        else:
+            prompt = f"{feature_type} {modification_type}"
+        
+        # Apply edit
+        edited_image = ledits_model.edit_image(
+            processed_image, 
+            mask, 
+            prompt, 
+            intensity=intensity
+        )
+        
+        # Postprocess
+        final_image = postprocess_image(edited_image, processed_image, mask)
+        
+        return final_image, "Edit completed successfully."
+    
+    except Exception as e:
+        return image, f"Error during editing: {str(e)}"
+
+# UI Components
+def create_ui():
+    with gr.Blocks(title="AI-Powered Facial & Body Feature Editor") as app:
+        gr.Markdown("# AI-Powered Facial & Body Feature Editor")
+        gr.Markdown("Upload an image and use the controls to edit specific facial and body features.")
+        
+        with gr.Row():
+            with gr.Column(scale=1):
+                # Input controls
+                input_image = gr.Image(label="Upload Image", type="pil")
+                
+                with gr.Group():
+                    gr.Markdown("### Feature Selection")
+                    feature_type = gr.Dropdown(
+                        choices=FEATURE_TYPES, 
+                        label="Select Feature", 
+                        value="Eyes"
+                    )
+                    
+                    modification_type = gr.Dropdown(
+                        choices=MODIFICATION_PRESETS["Eyes"], 
+                        label="Modification Type", 
+                        value="Larger"
+                    )
+                    
+                    intensity = gr.Slider(
+                        minimum=0.1, 
+                        maximum=1.0, 
+                        value=0.5, 
+                        step=0.1, 
+                        label="Intensity"
+                    )
+                
+                with gr.Group():
+                    gr.Markdown("### Custom Prompt (Advanced)")
+                    use_custom_prompt = gr.Checkbox(
+                        label="Use Custom Prompt", 
+                        value=False
+                    )
+                    custom_prompt = gr.Textbox(
+                        label="Custom Prompt", 
+                        placeholder="e.g., blue eyes with long eyelashes"
+                    )
+                
+                edit_button = gr.Button("Apply Edit", variant="primary")
+                reset_button = gr.Button("Reset")
+                status_text = gr.Textbox(label="Status", interactive=False)
+            
+            with gr.Column(scale=1):
+                # Output display
+                output_image = gr.Image(label="Edited Image", type="pil")
+                
+                with gr.Accordion("Edit History", open=False):
+                    edit_history = gr.State([])
+                    history_gallery = gr.Gallery(label="Previous Edits")
+        
+        # Event handlers
+        def update_modification_choices(feature):
+            return gr.Dropdown(choices=MODIFICATION_PRESETS[feature])
+        
+        feature_type.change(
+            fn=update_modification_choices,
+            inputs=feature_type,
+            outputs=modification_type
+        )
+        
+        edit_button.click(
+            fn=edit_image,
+            inputs=[
+                input_image, 
+                feature_type, 
+                modification_type, 
+                intensity, 
+                custom_prompt, 
+                use_custom_prompt
+            ],
+            outputs=[output_image, status_text]
+        )
+        
+        def reset_image():
+            return None, "Image reset."
+        
+        reset_button.click(
+            fn=reset_image,
+            inputs=[],
+            outputs=[output_image, status_text]
+        )
+        
+        # Add examples
+        gr.Examples(
+            examples=[
+                ["assets/example1.jpg", "Eyes", "Larger", 0.5, "", False],
+                ["assets/example2.jpg", "Lips", "Fuller", 0.4, "", False],
+                ["assets/example3.jpg", "Face Shape", "Slim", 0.6, "", False],
+            ],
+            inputs=[
+                input_image, 
+                feature_type, 
+                modification_type, 
+                intensity, 
+                custom_prompt, 
+                use_custom_prompt
+            ],
+            outputs=[output_image, status_text],
+            fn=edit_image,
+            cache_examples=True,
+        )
+        
+        # Add ethical usage notice
+        gr.Markdown("""
+        ## Ethical Usage Notice
+        
+        This tool is designed for creative and personal use. Please ensure:
+        
+        - You have appropriate rights to edit the images you upload
+        - You use this tool responsibly and respect the dignity of individuals
+        - You understand that AI-generated modifications are artificial and may not represent reality
+        
+        By using this application, you agree to these terms.
+        """)
+        
+    return app
+
+# Launch the app
+if __name__ == "__main__":
+    app = create_ui()
+    app.launch()

image-edit-app-pinokio.zip

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4493214b9975b54ff8860856d8a809b4e7092254c5b9df74d1e6159d16ad2b65
+size 13301

install.json

@@ -0,0 +1,75 @@
+{
+  "run": [
+    {
+      "method": "shell.run",
+      "params": {
+        "message": "mkdir -p feature-editor"
+      }
+    },
+    {
+      "method": "shell.run",
+      "params": {
+        "message": "{{os.platform() === 'win32' ? 'python' : 'python3'}} -m venv env",
+        "path": "feature-editor"
+      }
+    },
+    {
+      "method": "shell.start",
+      "params": {
+        "path": "feature-editor"
+      }
+    },
+    {
+      "method": "shell.enter",
+      "params": {
+        "message": "{{os.platform() === 'win32' ? 'env\\\\Scripts\\\\activate' : 'source env/bin/activate'}}",
+        "on": [
+          {
+            "event": null,
+            "return": true
+          }
+        ]
+      }
+    },
+    {
+      "method": "shell.enter",
+      "params": {
+        "message": "pip install gradio diffusers transformers opencv-python pillow numpy torch torchvision",
+        "on": [
+          {
+            "event": null,
+            "return": true
+          }
+        ]
+      }
+    },
+    {
+      "method": "fs.copy",
+      "params": {
+        "from": "app.py",
+        "to": "feature-editor/app.py"
+      }
+    },
+    {
+      "method": "fs.copy",
+      "params": {
+        "from": "utils",
+        "to": "feature-editor/utils"
+      }
+    },
+    {
+      "method": "fs.copy",
+      "params": {
+        "from": "models",
+        "to": "feature-editor/models"
+      }
+    },
+    {
+      "method": "input",
+      "params": {
+        "title": "Installation Complete",
+        "description": "AI Facial & Body Feature Editor has been successfully installed. Go back to the dashboard and launch the app!"
+      }
+    }
+  ]
+}

models/ledits_model.py

@@ -0,0 +1,218 @@
+import torch
+import numpy as np
+from diffusers import StableDiffusionInpaintPipeline, DDIMScheduler
+from PIL import Image
+
+class LEDITSModel:
+    """
+    Implementation of LEDITS++ model for localized image editing using Stable Diffusion.
+    """
+    
+    def __init__(self, model_id="runwayml/stable-diffusion-inpainting", device=None):
+        """
+        Initialize the LEDITS++ model.
+        
+        Args:
+            model_id (str): Hugging Face model ID for the Stable Diffusion inpainting model
+            device (str, optional): Device to run the model on ('cuda' or 'cpu')
+        """
+        self.model_id = model_id
+        
+        # Determine device
+        if device is None:
+            self.device = "cuda" if torch.cuda.is_available() else "cpu"
+        else:
+            self.device = device
+            
+        # Model will be loaded on first use to save memory
+        self.pipe = None
+        
+    def load_model(self):
+        """
+        Load the Stable Diffusion inpainting model.
+        """
+        if self.pipe is None:
+            # Load the pipeline with DDIM scheduler for better quality
+            scheduler = DDIMScheduler.from_pretrained(
+                self.model_id,
+                subfolder="scheduler"
+            )
+            
+            self.pipe = StableDiffusionInpaintPipeline.from_pretrained(
+                self.model_id,
+                scheduler=scheduler,
+                safety_checker=None  # Disable safety checker for NSFW content as per user request
+            )
+            
+            # Move to device
+            self.pipe = self.pipe.to(self.device)
+            
+            # Enable memory optimization if on CUDA
+            if self.device == "cuda":
+                self.pipe.enable_attention_slicing()
+    
+    def edit_image(self, image, mask, prompt, intensity=0.5, guidance_scale=7.5, num_inference_steps=30):
+        """
+        Edit an image using the LEDITS++ approach.
+        
+        Args:
+            image (numpy.ndarray): Input image (normalized to [0, 1])
+            mask (numpy.ndarray): Mask indicating the region to edit (values in [0, 1])
+            prompt (str): Text prompt describing the desired edit
+            intensity (float): Strength of the edit (0.0 to 1.0)
+            guidance_scale (float): Guidance scale for diffusion model
+            num_inference_steps (int): Number of denoising steps
+            
+        Returns:
+            numpy.ndarray: Edited image
+        """
+        # Load model if not already loaded
+        self.load_model()
+        
+        # Convert numpy arrays to PIL Images
+        if isinstance(image, np.ndarray):
+            # Convert to uint8 if the image is float
+            if image.dtype == np.float32 or image.dtype == np.float64:
+                image_pil = Image.fromarray((image * 255).astype(np.uint8))
+            else:
+                image_pil = Image.fromarray(image)
+        else:
+            image_pil = image
+            
+        if isinstance(mask, np.ndarray):
+            # Convert to uint8 if the mask is float
+            if mask.dtype == np.float32 or mask.dtype == np.float64:
+                mask_pil = Image.fromarray((mask * 255).astype(np.uint8))
+            else:
+                mask_pil = Image.fromarray(mask)
+                
+            # Ensure mask is grayscale
+            if mask_pil.mode != 'L':
+                mask_pil = mask_pil.convert('L')
+        else:
+            mask_pil = mask
+            
+        # Resize images to multiples of 8 (required by Stable Diffusion)
+        width, height = image_pil.size
+        new_width = width - (width % 8)
+        new_height = height - (height % 8)
+        
+        if (new_width, new_height) != image_pil.size:
+            image_pil = image_pil.resize((new_width, new_height), Image.LANCZOS)
+            mask_pil = mask_pil.resize((new_width, new_height), Image.LANCZOS)
+        
+        # Run the inpainting pipeline
+        with torch.no_grad():
+            output = self.pipe(
+                prompt=prompt,
+                image=image_pil,
+                mask_image=mask_pil,
+                guidance_scale=guidance_scale,
+                num_inference_steps=num_inference_steps,
+                strength=intensity,
+            ).images[0]
+        
+        # Convert back to numpy array
+        output_np = np.array(output) / 255.0
+        
+        return output_np
+    
+    def __del__(self):
+        """
+        Clean up resources when the object is deleted.
+        """
+        if self.pipe is not None and self.device == "cuda":
+            try:
+                # Clear CUDA cache
+                torch.cuda.empty_cache()
+            except:
+                pass
+
+
+class StableDiffusionModel:
+    """
+    Implementation of Stable Diffusion model for image generation and editing.
+    """
+    
+    def __init__(self, model_id="runwayml/stable-diffusion-v1-5", device=None):
+        """
+        Initialize the Stable Diffusion model.
+        
+        Args:
+            model_id (str): Hugging Face model ID for the Stable Diffusion model
+            device (str, optional): Device to run the model on ('cuda' or 'cpu')
+        """
+        self.model_id = model_id
+        
+        # Determine device
+        if device is None:
+            self.device = "cuda" if torch.cuda.is_available() else "cpu"
+        else:
+            self.device = device
+            
+        # Model will be loaded on first use to save memory
+        self.pipe = None
+        
+    def load_model(self):
+        """
+        Load the Stable Diffusion model.
+        """
+        if self.pipe is None:
+            from diffusers import StableDiffusionPipeline
+            
+            self.pipe = StableDiffusionPipeline.from_pretrained(
+                self.model_id,
+                safety_checker=None  # Disable safety checker for NSFW content as per user request
+            )
+            
+            # Move to device
+            self.pipe = self.pipe.to(self.device)
+            
+            # Enable memory optimization if on CUDA
+            if self.device == "cuda":
+                self.pipe.enable_attention_slicing()
+    
+    def generate_image(self, prompt, negative_prompt="", width=512, height=512, guidance_scale=7.5, num_inference_steps=30):
+        """
+        Generate an image using Stable Diffusion.
+        
+        Args:
+            prompt (str): Text prompt describing the desired image
+            negative_prompt (str): Text prompt describing what to avoid
+            width (int): Width of the generated image
+            height (int): Height of the generated image
+            guidance_scale (float): Guidance scale for diffusion model
+            num_inference_steps (int): Number of denoising steps
+            
+        Returns:
+            numpy.ndarray: Generated image
+        """
+        # Load model if not already loaded
+        self.load_model()
+        
+        # Run the pipeline
+        with torch.no_grad():
+            output = self.pipe(
+                prompt=prompt,
+                negative_prompt=negative_prompt,
+                width=width,
+                height=height,
+                guidance_scale=guidance_scale,
+                num_inference_steps=num_inference_steps,
+            ).images[0]
+        
+        # Convert to numpy array
+        output_np = np.array(output) / 255.0
+        
+        return output_np
+    
+    def __del__(self):
+        """
+        Clean up resources when the object is deleted.
+        """
+        if self.pipe is not None and self.device == "cuda":
+            try:
+                # Clear CUDA cache
+                torch.cuda.empty_cache()
+            except:
+                pass

pinokio.js

@@ -0,0 +1,15 @@
+module.exports = {
+  title: "PortraitPerfectAI",
+  description: "AI-Powered Facial & Body Feature Editor",
+  icon: "icon.png",
+  menu: [
+    {
+      html: '<i class="fa-solid fa-microchip"></i> Install',
+      href: "install.json"
+    },
+    {
+      html: '<i class="fa-solid fa-rocket"></i> Launch',
+      href: "run.json"
+    }
+  ]
+}

run.json

@@ -0,0 +1,10 @@
+{
+  "run": [
+    {
+      "method": "python",
+      "params": {
+        "script": "feature-editor/app.py"
+      }
+    }
+  ]
+}

utils/feature_detection.py

@@ -0,0 +1,196 @@
+import numpy as np
+import cv2
+from PIL import Image
+
+def detect_features(image):
+    """
+    Detect facial and body features in the input image.
+    
+    Args:
+        image (numpy.ndarray): Input image in numpy array format
+        
+    Returns:
+        dict: Dictionary containing detected features and their coordinates
+    """
+    # Convert to uint8 if the image is float
+    if image.dtype == np.float32 or image.dtype == np.float64:
+        image_uint8 = (image * 255).astype(np.uint8)
+    else:
+        image_uint8 = image
+        
+    # Initialize feature dictionary
+    features = {
+        "Eyes": [],
+        "Nose": [],
+        "Lips": [],
+        "Face": [],
+        "Hair": [],
+        "Body": []
+    }
+    
+    # Load pre-trained face detector
+    face_cascade = cv2.CascadeClassifier(cv2.data.haarcascades + 'haarcascade_frontalface_default.xml')
+    eye_cascade = cv2.CascadeClassifier(cv2.data.haarcascades + 'haarcascade_eye.xml')
+    
+    # Convert to grayscale for detection
+    gray = cv2.cvtColor(image_uint8, cv2.COLOR_RGB2GRAY)
+    
+    # Detect faces
+    faces = face_cascade.detectMultiScale(gray, 1.3, 5)
+    
+    for (x, y, w, h) in faces:
+        # Add face to features
+        features["Face"].append((x, y, w, h))
+        
+        # Define regions of interest for other facial features
+        face_roi = gray[y:y+h, x:x+w]
+        
+        # Detect eyes
+        eyes = eye_cascade.detectMultiScale(face_roi)
+        for (ex, ey, ew, eh) in eyes:
+            features["Eyes"].append((x+ex, y+ey, ew, eh))
+        
+        # Approximate nose position (center of face)
+        nose_w = w // 4
+        nose_h = h // 4
+        nose_x = x + w//2 - nose_w//2
+        nose_y = y + h//2 - nose_h//2
+        features["Nose"].append((nose_x, nose_y, nose_w, nose_h))
+        
+        # Approximate lips position (lower third of face)
+        lips_w = w // 2
+        lips_h = h // 6
+        lips_x = x + w//2 - lips_w//2
+        lips_y = y + 2*h//3
+        features["Lips"].append((lips_x, lips_y, lips_w, lips_h))
+        
+        # Approximate hair region (top of face and above)
+        hair_w = w
+        hair_h = h // 2
+        hair_x = x
+        hair_y = max(0, y - hair_h // 2)
+        features["Hair"].append((hair_x, hair_y, hair_w, hair_h))
+    
+    # If no faces detected, use whole image as body
+    if len(faces) == 0:
+        h, w = image.shape[:2]
+        features["Body"].append((0, 0, w, h))
+    else:
+        # Approximate body region (below face)
+        for (x, y, w, h) in faces:
+            body_w = w * 2
+            body_h = h * 3
+            body_x = max(0, x - w//2)
+            body_y = y + h
+            body_w = min(body_w, image.shape[1] - body_x)
+            body_h = min(body_h, image.shape[0] - body_y)
+            features["Body"].append((body_x, body_y, body_w, body_h))
+    
+    return features
+
+def create_mask(image, feature_type, features):
+    """
+    Create a binary mask for the selected feature type.
+    
+    Args:
+        image (numpy.ndarray): Input image
+        feature_type (str): Type of feature to mask
+        features (dict): Dictionary of detected features
+        
+    Returns:
+        numpy.ndarray: Binary mask highlighting the selected feature
+    """
+    # Create empty mask
+    mask = np.zeros(image.shape[:2], dtype=np.float32)
+    
+    # Map feature_type to the corresponding key in features dictionary
+    if feature_type == "Face Shape":
+        feature_key = "Face"
+    elif feature_type in features:
+        feature_key = feature_type
+    else:
+        # Default to Face if feature type not found
+        feature_key = "Face"
+    
+    # Draw filled rectangles for the selected feature
+    for (x, y, w, h) in features[feature_key]:
+        # Create a filled rectangle
+        cv2.rectangle(mask, (x, y), (x+w, y+h), 1.0, -1)
+    
+    # Apply Gaussian blur to soften the mask edges
+    mask = cv2.GaussianBlur(mask, (21, 21), 0)
+    
+    # Normalize mask to range [0, 1]
+    if mask.max() > 0:
+        mask = mask / mask.max()
+    
+    return mask
+
+def refine_mask_with_segmentation(image, mask, feature_type):
+    """
+    Refine the initial mask using image segmentation for more precise feature isolation.
+    
+    Args:
+        image (numpy.ndarray): Input image
+        mask (numpy.ndarray): Initial mask
+        feature_type (str): Type of feature to mask
+        
+    Returns:
+        numpy.ndarray: Refined binary mask
+    """
+    # Convert to uint8 if the image is float
+    if image.dtype == np.float32 or image.dtype == np.float64:
+        image_uint8 = (image * 255).astype(np.uint8)
+    else:
+        image_uint8 = image
+    
+    # Create a masked region to focus segmentation
+    masked_region = image_uint8.copy()
+    for c in range(3):
+        masked_region[:, :, c] = masked_region[:, :, c] * mask
+    
+    # Apply GrabCut algorithm for better segmentation
+    # Create initial mask for GrabCut
+    grabcut_mask = np.zeros(image.shape[:2], dtype=np.uint8)
+    
+    # Areas with high mask values (>0.5) are definitely foreground
+    grabcut_mask[mask > 0.5] = cv2.GC_PR_FGD
+    
+    # Areas with some mask values (>0.1) are probably foreground
+    grabcut_mask[(mask > 0.1) & (mask <= 0.5)] = cv2.GC_PR_FGD
+    
+    # Rest is probably background
+    grabcut_mask[mask <= 0.1] = cv2.GC_PR_BGD
+    
+    # Create temporary arrays for GrabCut
+    bgd_model = np.zeros((1, 65), np.float64)
+    fgd_model = np.zeros((1, 65), np.float64)
+    
+    # Apply GrabCut
+    try:
+        cv2.grabCut(
+            image_uint8, 
+            grabcut_mask, 
+            None, 
+            bgd_model, 
+            fgd_model, 
+            5, 
+            cv2.GC_INIT_WITH_MASK
+        )
+    except:
+        # If GrabCut fails, return the original mask
+        return mask
+    
+    # Create refined mask
+    refined_mask = np.zeros_like(mask)
+    refined_mask[grabcut_mask == cv2.GC_FGD] = 1.0
+    refined_mask[grabcut_mask == cv2.GC_PR_FGD] = 0.8
+    
+    # Apply Gaussian blur to soften the mask edges
+    refined_mask = cv2.GaussianBlur(refined_mask, (15, 15), 0)
+    
+    # Normalize mask to range [0, 1]
+    if refined_mask.max() > 0:
+        refined_mask = refined_mask / refined_mask.max()
+    
+    return refined_mask

utils/image_processing.py

@@ -0,0 +1,165 @@
+import numpy as np
+import cv2
+from PIL import Image
+
+def preprocess_image(image):
+    """
+    Preprocess the input image for AI model processing.
+    
+    Args:
+        image (numpy.ndarray): Input image in numpy array format
+        
+    Returns:
+        numpy.ndarray: Preprocessed image
+    """
+    # Convert to RGB if needed
+    if len(image.shape) == 2:
+        image = cv2.cvtColor(image, cv2.COLOR_GRAY2RGB)
+    elif image.shape[2] == 4:
+        # Handle RGBA images by removing alpha channel
+        image = image[:, :, :3]
+    
+    # Resize if needed (models typically expect specific dimensions)
+    # Using 512x512 as a common size for diffusion models
+    height, width = image.shape[:2]
+    max_dim = 512
+    
+    if height > max_dim or width > max_dim:
+        # Maintain aspect ratio
+        if height > width:
+            new_height = max_dim
+            new_width = int(width * (max_dim / height))
+        else:
+            new_width = max_dim
+            new_height = int(height * (max_dim / width))
+        
+        image = cv2.resize(image, (new_width, new_height), interpolation=cv2.INTER_AREA)
+    
+    # Normalize pixel values to [0, 1]
+    image = image.astype(np.float32) / 255.0
+    
+    return image
+
+def postprocess_image(edited_image, original_image, mask=None):
+    """
+    Postprocess the edited image, blending it with the original if needed.
+    
+    Args:
+        edited_image (numpy.ndarray): Edited image from the AI model
+        original_image (numpy.ndarray): Original input image
+        mask (numpy.ndarray, optional): Mask used for blending
+        
+    Returns:
+        PIL.Image: Final processed image
+    """
+    # Convert back to uint8 range [0, 255]
+    if edited_image.max() <= 1.0:
+        edited_image = (edited_image * 255.0).astype(np.uint8)
+    
+    if original_image.max() <= 1.0:
+        original_image = (original_image * 255.0).astype(np.uint8)
+    
+    # Resize edited image to match original if needed
+    if edited_image.shape[:2] != original_image.shape[:2]:
+        edited_image = cv2.resize(
+            edited_image, 
+            (original_image.shape[1], original_image.shape[0]), 
+            interpolation=cv2.INTER_LANCZOS4
+        )
+    
+    # If mask is provided, blend the edited and original images
+    if mask is not None:
+        # Ensure mask is properly sized
+        if mask.shape[:2] != original_image.shape[:2]:
+            mask = cv2.resize(
+                mask, 
+                (original_image.shape[1], original_image.shape[0]), 
+                interpolation=cv2.INTER_LINEAR
+            )
+        
+        # Ensure mask is in proper format (single channel, values between 0 and 1)
+        if len(mask.shape) > 2:
+            mask = mask[:, :, 0]
+        
+        if mask.max() > 1.0:
+            mask = mask / 255.0
+        
+        # Apply Gaussian blur to mask for smoother blending
+        mask = cv2.GaussianBlur(mask, (15, 15), 0)
+        
+        # Expand mask dimensions for broadcasting
+        mask_3d = np.expand_dims(mask, axis=2)
+        mask_3d = np.repeat(mask_3d, 3, axis=2)
+        
+        # Blend images
+        blended = (mask_3d * edited_image) + ((1 - mask_3d) * original_image)
+        final_image = blended.astype(np.uint8)
+    else:
+        final_image = edited_image
+    
+    # Convert to PIL Image for Gradio
+    return Image.fromarray(final_image)
+
+def apply_quality_matching(edited_image, reference_image):
+    """
+    Match the quality, lighting, and texture of the edited image to the reference image.
+    
+    Args:
+        edited_image (numpy.ndarray): Edited image to adjust
+        reference_image (numpy.ndarray): Reference image to match quality with
+        
+    Returns:
+        numpy.ndarray: Quality-matched image
+    """
+    # Convert to LAB color space for better color matching
+    edited_lab = cv2.cvtColor(edited_image, cv2.COLOR_RGB2LAB)
+    reference_lab = cv2.cvtColor(reference_image, cv2.COLOR_RGB2LAB)
+    
+    # Split channels
+    edited_l, edited_a, edited_b = cv2.split(edited_lab)
+    reference_l, reference_a, reference_b = cv2.split(reference_lab)
+    
+    # Match luminance histogram
+    matched_l = match_histogram(edited_l, reference_l)
+    
+    # Recombine channels
+    matched_lab = cv2.merge([matched_l, edited_a, edited_b])
+    matched_rgb = cv2.cvtColor(matched_lab, cv2.COLOR_LAB2RGB)
+    
+    # Ensure values are in valid range
+    matched_rgb = np.clip(matched_rgb, 0, 1.0)
+    
+    return matched_rgb
+
+def match_histogram(source, reference):
+    """
+    Match the histogram of the source image to the reference image.
+    
+    Args:
+        source (numpy.ndarray): Source image channel
+        reference (numpy.ndarray): Reference image channel
+        
+    Returns:
+        numpy.ndarray: Histogram-matched image channel
+    """
+    # Calculate histograms
+    src_hist, src_bins = np.histogram(source.flatten(), 256, [0, 256], density=True)
+    ref_hist, ref_bins = np.histogram(reference.flatten(), 256, [0, 256], density=True)
+    
+    # Calculate cumulative distribution functions
+    src_cdf = src_hist.cumsum()
+    src_cdf = src_cdf / src_cdf[-1]
+    
+    ref_cdf = ref_hist.cumsum()
+    ref_cdf = ref_cdf / ref_cdf[-1]
+    
+    # Create lookup table
+    lookup_table = np.zeros(256)
+    for i in range(256):
+        # Find the closest value in ref_cdf to src_cdf[i]
+        lookup_table[i] = np.argmin(np.abs(ref_cdf - src_cdf[i]))
+    
+    # Apply lookup table
+    result = lookup_table[source.astype(np.uint8)]
+    
+    return result.astype(np.uint8)