Upload 15 files

app.py

@@ -1,4 +1,3 @@
-import os
 import sys
 import traceback
 import warnings
@@ -6,45 +5,6 @@ warnings.filterwarnings("ignore")
 
 from ui_manager import UIManager
 
-def preload_models_to_cache():
-    """
-    Pre-download models to HuggingFace cache before GPU allocation.
-    This runs on CPU and avoids downloading during @spaces.GPU execution.
-    """
-    if not os.getenv('SPACE_ID'):
-        return  # Skip if not on Spaces
-
-    print("📦 Pre-downloading models to cache (CPU only, no GPU usage)...")
-
-    try:
-        from diffusers import ControlNetModel
-        import torch
-
-        # Pre-download ControlNet models to cache
-        models_to_cache = [
-            ("diffusers/controlnet-canny-sdxl-1.0", "Canny ControlNet"),
-            ("diffusers/controlnet-depth-sdxl-1.0", "Depth ControlNet"),
-        ]
-
-        for model_id, model_name in models_to_cache:
-            print(f"  ⬇️  Downloading {model_name} ({model_id})...")
-            try:
-                _ = ControlNetModel.from_pretrained(
-                    model_id,
-                    torch_dtype=torch.float16,
-                    use_safetensors=True,
-                    local_files_only=False  # Allow download
-                )
-                print(f"  ✅ {model_name} cached")
-            except Exception as e:
-                print(f"  ⚠️  {model_name} download failed (will retry on-demand): {e}")
-
-        print("✅ Model pre-caching complete")
-
-    except Exception as e:
-        print(f"⚠️  Model pre-caching failed: {e}")
-        print("   Models will be downloaded on first use instead.")
-
 def launch_final_blend_sceneweaver(share: bool = True, debug: bool = False):
     """Launch SceneWeaver Application"""
 
@@ -52,9 +12,6 @@ def launch_final_blend_sceneweaver(share: bool = True, debug: bool = False):
     print("✨ AI-Powered Image Background Generation")
 
     try:
-        # Pre-download models on Spaces to avoid downloading during GPU time
-        preload_models_to_cache()
-
         # Test imports first
         print("🔍 Testing imports...")
         try:
@@ -63,13 +20,6 @@ def launch_final_blend_sceneweaver(share: bool = True, debug: bool = False):
             ui = UIManager()
             print("✅ UIManager instance created successfully")
 
-            # Note: On Hugging Face Spaces, models are pre-cached at startup
-            if os.getenv('SPACE_ID'):
-                print("\n🔧 Detected Hugging Face Spaces environment")
-                print("⚡ Models pre-cached - ready for fast inference")
-                print("   Expected inference time: ~300-350s (with cached models)")
-                print()
-
             # Launch UI
             print("🚀 Launching interface...")
             interface = ui.launch(share=share, debug=debug)
@@ -128,4 +78,4 @@ def main():
         raise
 
 if __name__ == "__main__":
-    main()
+    main()

control_image_processor.py

@@ -0,0 +1,392 @@
+import logging
+from typing import Optional, Tuple
+
+import cv2
+import numpy as np
+import torch
+from PIL import Image, ImageFilter
+
+from transformers import AutoImageProcessor, AutoModelForDepthEstimation
+from transformers import DPTImageProcessor, DPTForDepthEstimation
+
+logger = logging.getLogger(__name__)
+logger.setLevel(logging.INFO)
+
+
+class ControlImageProcessor:
+    """
+    Generates control images for ControlNet conditioning.
+
+    Supports Canny edge detection and depth map estimation with
+    mask-aware processing for selective structure preservation.
+
+    Attributes:
+        device: Computation device (cuda/mps/cpu)
+        canny_low_threshold: Low threshold for Canny edge detection
+        canny_high_threshold: High threshold for Canny edge detection
+
+    Example:
+        >>> processor = ControlImageProcessor(device="cuda")
+        >>> canny_image = processor.generate_canny_edges(image)
+        >>> depth_map = processor.generate_depth_map(image)
+    """
+
+    # Depth model identifiers
+    DEPTH_MODEL_PRIMARY = "LiheYoung/depth-anything-small-hf"
+    DEPTH_MODEL_FALLBACK = "Intel/dpt-hybrid-midas"
+
+    def __init__(
+        self,
+        device: str = "cuda",
+        canny_low_threshold: int = 100,
+        canny_high_threshold: int = 200
+    ):
+        """
+        Initialize the ControlImageProcessor.
+
+        Parameters
+        ----------
+        device : str
+            Computation device
+        canny_low_threshold : int
+            Low threshold for Canny edge detection
+        canny_high_threshold : int
+            High threshold for Canny edge detection
+        """
+        self.device = device
+        self.canny_low_threshold = canny_low_threshold
+        self.canny_high_threshold = canny_high_threshold
+
+        # Depth estimation models (lazy loaded)
+        self._depth_estimator = None
+        self._depth_processor = None
+        self._depth_model_loaded = False
+
+        logger.info(f"ControlImageProcessor initialized on {device}")
+
+    def generate_canny_edges(self, image: np.ndarray) -> Image.Image:
+        """
+        Generate Canny edge detection image.
+
+        Parameters
+        ----------
+        image : np.ndarray
+            Input image as numpy array (RGB)
+
+        Returns
+        -------
+        PIL.Image
+            Canny edge image (grayscale)
+        """
+        # Convert to grayscale
+        if len(image.shape) == 3:
+            gray = cv2.cvtColor(image, cv2.COLOR_RGB2GRAY)
+        else:
+            gray = image
+
+        # Apply Gaussian blur to reduce noise
+        blurred = cv2.GaussianBlur(gray, (5, 5), 1.4)
+
+        # Canny edge detection
+        edges = cv2.Canny(
+            blurred,
+            self.canny_low_threshold,
+            self.canny_high_threshold
+        )
+
+        # Convert to 3-channel for ControlNet
+        edges_3ch = cv2.cvtColor(edges, cv2.COLOR_GRAY2RGB)
+
+        return Image.fromarray(edges_3ch)
+
+    def load_depth_estimator(self) -> bool:
+        """
+        Load depth estimation model.
+
+        Returns
+        -------
+        bool
+            True if loaded successfully
+        """
+        if self._depth_model_loaded:
+            return True
+
+        logger.info("Loading depth estimation model...")
+
+        try:
+            # Try primary model first (Depth Anything)
+            self._depth_processor = AutoImageProcessor.from_pretrained(
+                self.DEPTH_MODEL_PRIMARY
+            )
+            self._depth_estimator = AutoModelForDepthEstimation.from_pretrained(
+                self.DEPTH_MODEL_PRIMARY,
+                torch_dtype=torch.float16 if self.device == "cuda" else torch.float32
+            )
+            self._depth_estimator = self._depth_estimator.to(self.device)
+            self._depth_estimator.eval()
+            self._depth_model_loaded = True
+            logger.info(f"Loaded depth model: {self.DEPTH_MODEL_PRIMARY}")
+            return True
+
+        except Exception as e:
+            logger.warning(f"Primary depth model failed: {e}, trying fallback...")
+
+            try:
+                # Fallback to DPT
+                self._depth_processor = DPTImageProcessor.from_pretrained(
+                    self.DEPTH_MODEL_FALLBACK
+                )
+                self._depth_estimator = DPTForDepthEstimation.from_pretrained(
+                    self.DEPTH_MODEL_FALLBACK,
+                    torch_dtype=torch.float16 if self.device == "cuda" else torch.float32
+                )
+                self._depth_estimator = self._depth_estimator.to(self.device)
+                self._depth_estimator.eval()
+                self._depth_model_loaded = True
+                logger.info(f"Loaded fallback depth model: {self.DEPTH_MODEL_FALLBACK}")
+                return True
+
+            except Exception as e2:
+                logger.error(f"All depth models failed: {e2}")
+                return False
+
+    def generate_depth_map(self, image: Image.Image) -> Image.Image:
+        """
+        Generate depth map using depth estimation model.
+
+        Parameters
+        ----------
+        image : PIL.Image
+            Input image
+
+        Returns
+        -------
+        PIL.Image
+            Depth map image (grayscale, normalized)
+        """
+        if not self._depth_model_loaded:
+            if not self.load_depth_estimator():
+                # Fallback to simple gradient
+                logger.warning("Using fallback gradient depth")
+                return self._generate_fallback_depth(image)
+
+        try:
+            # Prepare image for model
+            inputs = self._depth_processor(
+                images=image,
+                return_tensors="pt"
+            )
+            inputs = {k: v.to(self.device) for k, v in inputs.items()}
+
+            # Run inference
+            with torch.no_grad():
+                outputs = self._depth_estimator(**inputs)
+                predicted_depth = outputs.predicted_depth
+
+            # Normalize depth map
+            depth = predicted_depth.squeeze().cpu().numpy()
+            depth = (depth - depth.min()) / (depth.max() - depth.min() + 1e-8)
+            depth = (depth * 255).astype(np.uint8)
+
+            # Resize to match input
+            depth_image = Image.fromarray(depth)
+            depth_image = depth_image.resize(image.size, Image.Resampling.BILINEAR)
+
+            # Convert to 3-channel for ControlNet
+            depth_3ch = np.stack([np.array(depth_image)] * 3, axis=-1)
+
+            return Image.fromarray(depth_3ch)
+
+        except Exception as e:
+            logger.error(f"Depth estimation failed: {e}")
+            return self._generate_fallback_depth(image)
+
+    def _generate_fallback_depth(self, image: Image.Image) -> Image.Image:
+        """
+        Generate a simple fallback depth map using gradient.
+
+        Parameters
+        ----------
+        image : PIL.Image
+            Input image
+
+        Returns
+        -------
+        PIL.Image
+            Simple gradient depth map
+        """
+        w, h = image.size
+        # Create vertical gradient (top = far, bottom = near)
+        gradient = np.linspace(50, 200, h).reshape(-1, 1)
+        gradient = np.tile(gradient, (1, w))
+        gradient = gradient.astype(np.uint8)
+
+        # Stack to 3 channels
+        depth_3ch = np.stack([gradient] * 3, axis=-1)
+        return Image.fromarray(depth_3ch)
+
+    def prepare_control_image(
+        self,
+        image: Image.Image,
+        mode: str = "canny",
+        mask: Optional[Image.Image] = None,
+        preserve_structure: bool = False,
+        edge_guidance_mode: str = "boundary"
+    ) -> Image.Image:
+        """
+        Generate ControlNet conditioning image.
+
+        Parameters
+        ----------
+        image : PIL.Image
+            Input image
+        mode : str
+            Conditioning mode: "canny" or "depth"
+        mask : PIL.Image, optional
+            If provided, can modify edges based on edge_guidance_mode
+        preserve_structure : bool
+            If True, keep all edges in masked region (for color change tasks)
+            If False, use edge_guidance_mode to determine edge handling
+        edge_guidance_mode : str
+            How to handle edges when preserve_structure=False:
+            - "none": Completely remove edges in masked region (removal tasks)
+            - "boundary": Keep only boundary edges of masked region (replacement tasks)
+            - "soft": Gradually fade edges from boundary (default for better blending)
+
+        Returns
+        -------
+        PIL.Image
+            Generated control image
+        """
+        logger.info(f"Preparing control image: mode={mode}, preserve_structure={preserve_structure}, edge_guidance={edge_guidance_mode}")
+
+        # Convert to RGB if needed
+        if image.mode != 'RGB':
+            image = image.convert('RGB')
+
+        img_array = np.array(image)
+
+        if mode == "canny":
+            control_image = self.generate_canny_edges(img_array)
+
+            if mask is not None:
+                control_array = np.array(control_image)
+                mask_array = np.array(mask.convert('L'))
+
+                if preserve_structure:
+                    # Keep all edges - no modification needed
+                    logger.info("Preserving all edges in masked region for color change")
+
+                elif edge_guidance_mode == "none":
+                    # Completely suppress edges in masked region (for removal)
+                    mask_region = mask_array > 128
+                    control_array[mask_region] = 0
+                    logger.info("Suppressed all edges in masked region for removal")
+
+                elif edge_guidance_mode == "mask_outline":
+                    # For object replacement: clear inside edges, draw clear mask outline
+                    # Outline guides WHERE and WHAT SIZE the new object should be
+                    mask_binary = (mask_array > 128).astype(np.uint8) * 255
+
+                    # Step 1: Clear all edges inside the mask
+                    mask_region = mask_array > 128
+                    control_array[mask_region] = 0
+
+                    # Step 2: Draw clear mask outline for position/size guidance
+                    contours, _ = cv2.findContours(
+                        mask_binary,
+                        cv2.RETR_EXTERNAL,
+                        cv2.CHAIN_APPROX_SIMPLE
+                    )
+
+                    if contours:
+                        # Draw visible white outline (thickness=2) for clear guidance
+                        cv2.drawContours(control_array, contours, -1, (255, 255, 255), thickness=2)
+                        logger.info(f"Drew {len(contours)} mask outline(s) for placement guidance")
+
+                elif edge_guidance_mode == "boundary":
+                    # Keep boundary edges to guide object placement and size
+                    # This helps ControlNet understand WHERE to place the new object
+                    mask_binary = (mask_array > 128).astype(np.uint8) * 255
+
+                    # Create boundary mask using morphological operations
+                    kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (15, 15))
+                    dilated = cv2.dilate(mask_binary, kernel, iterations=1)
+                    eroded = cv2.erode(mask_binary, kernel, iterations=1)
+                    boundary = dilated - eroded
+
+                    # Inner region (not boundary) - suppress edges
+                    inner_region = (mask_array > 128) & (boundary == 0)
+                    control_array[inner_region] = 0
+
+                    # Keep boundary edges intact for object placement guidance
+                    logger.info("Keeping boundary edges for object replacement guidance")
+
+                elif edge_guidance_mode == "soft":
+                    # Soft fade: gradually reduce edges from boundary to center
+                    mask_binary = (mask_array > 128).astype(np.uint8) * 255
+
+                    # Calculate distance from boundary
+                    dist_transform = cv2.distanceTransform(mask_binary, cv2.DIST_L2, 5)
+                    max_dist = dist_transform.max()
+                    if max_dist > 0:
+                        # Normalize and invert: 1 at boundary, 0 at center
+                        fade_factor = 1 - (dist_transform / max_dist)
+                        fade_factor = np.clip(fade_factor, 0, 1)
+
+                        # Apply fade to masked region only
+                        mask_region = mask_array > 128
+                        for c in range(3):
+                            control_array[:, :, c][mask_region] = (
+                                control_array[:, :, c][mask_region] * fade_factor[mask_region]
+                            ).astype(np.uint8)
+
+                    logger.info("Applied soft edge fading in masked region")
+
+                control_image = Image.fromarray(control_array)
+
+            return control_image
+
+        elif mode == "depth":
+            control_image = self.generate_depth_map(image)
+
+            # For depth mode with replacement, we want to keep depth info for context
+            # but allow flexibility in the masked region
+            if mask is not None and not preserve_structure:
+                control_array = np.array(control_image)
+                mask_array = np.array(mask.convert('L'))
+
+                # Smooth the depth in masked region using surrounding context
+                if edge_guidance_mode in ["boundary", "soft"]:
+                    mask_binary = (mask_array > 128).astype(np.uint8)
+
+                    # Inpaint the depth map in masked region using surrounding values
+                    depth_gray = control_array[:, :, 0]
+                    inpainted_depth = cv2.inpaint(
+                        depth_gray,
+                        mask_binary,
+                        inpaintRadius=10,
+                        flags=cv2.INPAINT_TELEA
+                    )
+                    control_array = np.stack([inpainted_depth] * 3, axis=-1)
+                    logger.info("Inpainted depth map in masked region")
+
+                control_image = Image.fromarray(control_array)
+
+            return control_image
+
+        else:
+            raise ValueError(f"Unknown control mode: {mode}")
+
+    def unload_depth_model(self) -> None:
+        """Unload depth estimation model to free memory."""
+        if self._depth_estimator is not None:
+            del self._depth_estimator
+            self._depth_estimator = None
+
+        if self._depth_processor is not None:
+            del self._depth_processor
+            self._depth_processor = None
+
+        self._depth_model_loaded = False
+        logger.info("Depth model unloaded")

gpu_handlers.py

@@ -0,0 +1,316 @@
+import logging
+import time
+from typing import Any, Callable, Dict, Optional, Tuple
+
+import cv2
+import numpy as np
+import spaces
+from PIL import Image
+
+logger = logging.getLogger(__name__)
+logger.setLevel(logging.INFO)
+
+
+class GPUHandlers:
+    """
+    Handles all GPU-intensive generation operations.
+
+    This class encapsulates the execution logic for both background generation
+    and inpainting operations with proper @spaces.GPU decorator for
+    HuggingFace Spaces deployment.
+
+    Supports dual-mode inpainting:
+    - Pure Inpainting (use_controlnet=False): For object replacement/removal
+    - ControlNet Inpainting (use_controlnet=True): For clothing/color change
+    """
+
+    def __init__(
+        self,
+        core: Any,
+        inpainting_template_manager: Any
+    ):
+        """
+        Initialize the GPU handlers.
+
+        Parameters
+        ----------
+        core : SceneWeaverCore
+            Main engine instance
+        inpainting_template_manager : InpaintingTemplateManager
+            Template manager for inpainting
+        """
+        self.core = core
+        self.inpainting_template_manager = inpainting_template_manager
+        logger.info("GPUHandlers initialized")
+
+    @spaces.GPU(duration=240)
+    def background_generate(
+        self,
+        image: Optional[Image.Image],
+        prompt: str,
+        negative_prompt: str,
+        composition_mode: str,
+        focus_mode: str,
+        num_steps: int,
+        guidance_scale: float,
+        progress_callback: Optional[Callable[[str, int], None]] = None
+    ) -> Dict[str, Any]:
+        """
+        Handle background generation request with GPU access.
+
+        Parameters
+        ----------
+        image : PIL.Image, optional
+            Input image
+        prompt : str
+            Generation prompt
+        negative_prompt : str
+            Negative prompt
+        composition_mode : str
+            Composition mode (center, left_half, etc.)
+        focus_mode : str
+            Focus mode (person, scene)
+        num_steps : int
+            Number of inference steps
+        guidance_scale : float
+            Guidance scale
+        progress_callback : callable, optional
+            Progress update function(message, percentage)
+
+        Returns
+        -------
+        dict
+            Result dictionary with success status and images
+        """
+        if image is None:
+            return {"success": False, "error": "Please upload an image first"}
+
+        if not prompt.strip():
+            return {"success": False, "error": "Please enter a prompt"}
+
+        try:
+            logger.info(f"Starting background generation: {prompt[:50]}...")
+            start_time = time.time()
+
+            # Initialize if needed
+            if not self.core.is_initialized:
+                if progress_callback:
+                    progress_callback("Loading AI models...", 5)
+                self.core.load_models(progress_callback=progress_callback)
+
+            # Generate and combine
+            if progress_callback:
+                progress_callback("Generating background...", 20)
+
+            result = self.core.generate_and_combine(
+                original_image=image,
+                prompt=prompt,
+                combination_mode=composition_mode,
+                focus_mode=focus_mode,
+                negative_prompt=negative_prompt,
+                num_inference_steps=num_steps,
+                guidance_scale=guidance_scale,
+                progress_callback=progress_callback
+            )
+
+            elapsed = time.time() - start_time
+            logger.info(f"Background generation complete in {elapsed:.1f}s")
+
+            return result
+
+        except Exception as e:
+            error_msg = str(e)
+            logger.error(f"Background generation error: {error_msg}")
+            return {"success": False, "error": error_msg}
+
+    @spaces.GPU(duration=420)
+    def inpainting_generate(
+        self,
+        image: Optional[Image.Image],
+        mask: Optional[Image.Image],
+        prompt: str,
+        template_key: Optional[str],
+        model_key: str,
+        conditioning_type: str,
+        conditioning_scale: float,
+        feather_radius: int,
+        guidance_scale: float,
+        num_steps: int,
+        seed: int = -1,
+        progress_callback: Optional[Callable[[str, int], None]] = None
+    ) -> Tuple[Optional[Image.Image], Optional[Image.Image], str, int]:
+        """
+        Handle inpainting request with GPU access.
+
+        Supports dual-mode operation based on template:
+        - Pure Inpainting: For object_replacement, removal
+        - ControlNet: For clothing_change, change_color
+
+        Parameters
+        ----------
+        image : PIL.Image
+            Original image to inpaint
+        mask : PIL.Image
+            Inpainting mask (white = area to regenerate)
+        prompt : str
+            Inpainting prompt
+        template_key : str, optional
+            Template key if using a template
+        model_key : str
+            Model key (juggernaut_xl, realvis_xl, sdxl_base, animagine_xl)
+        conditioning_type : str
+            ControlNet conditioning type (canny/depth) - only for ControlNet mode
+        conditioning_scale : float
+            ControlNet conditioning scale
+        feather_radius : int
+            Mask feather radius
+        guidance_scale : float
+            Generation guidance scale
+        num_steps : int
+            Number of inference steps
+        seed : int
+            Random seed (-1 for random)
+        progress_callback : callable, optional
+            Progress update function
+
+        Returns
+        -------
+        tuple
+            (result_image, control_image, status_message, used_seed)
+        """
+        if image is None:
+            return None, None, "Please upload an image first", -1
+
+        if mask is None:
+            return None, None, "Please draw a mask on the image", -1
+
+        try:
+            logger.info(f"Starting inpainting: prompt='{prompt[:30]}...', template={template_key}")
+            start_time = time.time()
+
+            # Get template parameters
+            built_prompt = prompt
+            negative_prompt = ""
+            template_params = {}
+            use_controlnet = True  # Default to ControlNet mode
+
+            if template_key:
+                template = self.inpainting_template_manager.get_template(template_key)
+                if template:
+                    # For removal template, use template prompt directly if user prompt is empty
+                    if template_key == "removal" and not prompt.strip():
+                        built_prompt = template.prompt_template
+                    else:
+                        built_prompt = self.inpainting_template_manager.build_prompt(template_key, prompt)
+                    negative_prompt = self.inpainting_template_manager.get_negative_prompt(template_key)
+                    template_params = self.inpainting_template_manager.get_parameters_for_template(template_key)
+                    use_controlnet = template_params.get("use_controlnet", True)
+                    logger.info(f"Template: {template_key}, use_controlnet={use_controlnet}")
+
+            # Build final parameters
+            final_params = {
+                # Pipeline mode
+                "use_controlnet": use_controlnet,
+                "mask_dilation": template_params.get("mask_dilation", 0),
+
+                # ControlNet parameters (only used if use_controlnet=True)
+                "conditioning_type": template_params.get("preferred_conditioning", conditioning_type),
+                "controlnet_conditioning_scale": template_params.get("controlnet_conditioning_scale", conditioning_scale),
+                "preserve_structure_in_mask": template_params.get("preserve_structure_in_mask", False),
+                "edge_guidance_mode": template_params.get("edge_guidance_mode", "boundary"),
+
+                # Generation parameters
+                "feather_radius": template_params.get("feather_radius", feather_radius),
+                "guidance_scale": template_params.get("guidance_scale", guidance_scale),
+                "num_inference_steps": template_params.get("num_inference_steps", num_steps),
+                "strength": template_params.get("strength", 0.99),
+                "negative_prompt": negative_prompt,
+                "seed": seed,
+            }
+
+            # Execute inpainting through core
+            result = self.core.execute_inpainting(
+                image=image,
+                mask=mask,
+                prompt=built_prompt,
+                model_key=model_key,
+                progress_callback=progress_callback,
+                **final_params
+            )
+
+            elapsed = time.time() - start_time
+
+            if result.get('success'):
+                mode_str = "Pure Inpainting" if not use_controlnet else "ControlNet"
+                # Get the actual seed used from metadata
+                used_seed = result.get('metadata', {}).get('seed', seed)
+                status = f"Complete ({mode_str}) in {elapsed:.1f}s | Seed: {used_seed}"
+
+                return (
+                    result.get('combined_image'),
+                    result.get('control_image'),
+                    status,
+                    used_seed
+                )
+            else:
+                error_msg = result.get('error', 'Unknown error')
+                return None, None, f"Error: {error_msg}", -1
+
+        except Exception as e:
+            error_msg = str(e)
+            logger.error(f"Inpainting handler error: {e}")
+            return None, None, f"Error: {error_msg}", -1
+
+
+def extract_mask_from_editor(mask_editor: Dict[str, Any]) -> Optional[Image.Image]:
+    """
+    Extract mask from Gradio ImageEditor component.
+
+    Parameters
+    ----------
+    mask_editor : dict
+        ImageEditor output with 'background' and 'layers'
+
+    Returns
+    -------
+    PIL.Image or None
+        Extracted mask image (L mode)
+    """
+    if mask_editor is None:
+        return None
+
+    try:
+        layers = mask_editor.get("layers", [])
+        if not layers:
+            return None
+
+        mask_layer = layers[0]
+        if mask_layer is None:
+            return None
+
+        # Convert to numpy array
+        if isinstance(mask_layer, Image.Image):
+            mask_array = np.array(mask_layer)
+        else:
+            mask_array = np.array(Image.open(mask_layer))
+
+        # Handle different formats
+        if len(mask_array.shape) == 3:
+            if mask_array.shape[2] == 4:
+                # RGBA - use alpha channel combined with RGB
+                alpha = mask_array[:, :, 3]
+                gray = cv2.cvtColor(mask_array[:, :, :3], cv2.COLOR_RGB2GRAY)
+                mask_gray = np.maximum(gray, alpha)
+            elif mask_array.shape[2] == 3:
+                # RGB - convert to grayscale
+                mask_gray = cv2.cvtColor(mask_array, cv2.COLOR_RGB2GRAY)
+            else:
+                mask_gray = mask_array[:, :, 0]
+        else:
+            mask_gray = mask_array
+
+        return Image.fromarray(mask_gray.astype(np.uint8), mode='L')
+
+    except Exception as e:
+        logger.error(f"Failed to extract mask from editor: {e}")
+        return None

image_blender.py

@@ -483,7 +483,7 @@ class ImageBlender:
         orig_bg_color_lab = cv2.cvtColor(orig_bg_color_rgb.reshape(1,1,3), cv2.COLOR_RGB2LAB)[0,0].astype(np.float32)
         logger.info(f"🎨 Detected original background color: RGB{tuple(orig_bg_color_rgb)}")
 
-        # Remove original background color contamination from foreground 
+        # Remove original background color contamination from foreground
         orig_array = self._remove_background_color_contamination(
             orig_array,
             mask_array,
@@ -491,7 +491,7 @@ class ImageBlender:
             tolerance=self.BACKGROUND_COLOR_TOLERANCE
         )
 
-        # Redefine trimap, optimized for cartoon characters 
+        # Redefine trimap, optimized for cartoon characters
         try:
             kernel_3x3 = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (3, 3))
 
@@ -531,7 +531,7 @@ class ImageBlender:
 
         fg_rep_color_lab = cv2.cvtColor(fg_rep_color_rgb.reshape(1,1,3), cv2.COLOR_RGB2LAB)[0,0].astype(np.float32)
 
-        # Edge band spill suppression and repair 
+        # Edge band spill suppression and repair
         if np.any(ring_zone):
             # Convert to Lab space
             orig_lab = cv2.cvtColor(orig_array, cv2.COLOR_RGB2LAB).astype(np.float32)
@@ -625,20 +625,20 @@ class ImageBlender:
                 delta_a_pass2 = ring_pixels_lab_pass2[:, 1] - orig_bg_color_lab[1]
                 delta_b_pass2 = ring_pixels_lab_pass2[:, 2] - orig_bg_color_lab[2]
                 delta_e_pass2 = np.sqrt(delta_l_pass2**2 + delta_a_pass2**2 + delta_b_pass2**2)
-                
+
                 still_contaminated = delta_e_pass2 < (DELTAE_THRESHOLD * 0.8)
-                
+
                 if np.any(still_contaminated):
                     # Apply stronger correction to remaining contaminated pixels
                     remaining_pixels = ring_pixels_lab_pass2[still_contaminated]
-                    
+
                     # More aggressive chroma neutralization
                     remaining_chroma = remaining_pixels[:, 1:3]
                     neutralized_chroma = remaining_chroma * 0.3 + fg_rep_color_lab[1:3] * 0.7
-                    
+
                     # Stronger luminance matching
                     neutralized_l = remaining_pixels[:, 0] * 0.4 + fg_rep_color_lab[0] * 0.6
-                    
+
                     ring_pixels_lab_pass2[still_contaminated, 0] = neutralized_l
                     ring_pixels_lab_pass2[still_contaminated, 1:3] = neutralized_chroma
                     orig_lab[ring_zone] = ring_pixels_lab_pass2
@@ -691,7 +691,7 @@ class ImageBlender:
         orig_linear = srgb_to_linear(orig_array)
         bg_linear = srgb_to_linear(bg_array)
 
-        # Cartoon-optimized Alpha calculation 
+        # Cartoon-optimized Alpha calculation
         alpha = mask_array.astype(np.float32) / 255.0
 
         # Core foreground region - fully opaque
@@ -701,13 +701,13 @@ class ImageBlender:
         alpha[bg_zone] = 0.0
 
         # [Key Fix] Force pixels with mask≥160 to α=1.0, avoiding white fill areas being limited to 0.9
-        high_confidence_pixels = mask_array >= 160  
+        high_confidence_pixels = mask_array >= 160
         alpha[high_confidence_pixels] = 1.0
         logger.info(f"💯 High confidence pixels set to full opacity: {high_confidence_pixels.sum()}")
 
         # Ring area can be dehaloed, but doesn't affect already set high confidence pixels
         ring_without_high_conf = ring_zone & (~high_confidence_pixels)
-        alpha[ring_without_high_conf] = np.clip(alpha[ring_without_high_conf], 0.2, 0.9)  
+        alpha[ring_without_high_conf] = np.clip(alpha[ring_without_high_conf], 0.2, 0.9)
 
         # Retain existing black outline/strong edge protection
         orig_gray = np.mean(orig_array, axis=2)
@@ -739,10 +739,10 @@ class ImageBlender:
         result_srgb = linear_to_srgb(result_linear)
         result_array = (result_srgb * 255).astype(np.uint8)
 
-        # Final edge cleanup pass 
+        # Final edge cleanup pass
         result_array = self._apply_edge_cleanup(result_array, bg_array, alpha)
 
-        # Protect core foreground from any background influence 
+        # Protect core foreground from any background influence
         # This ensures faces and bodies retain original colors
         result_array = self._protect_foreground_core(
             result_array,

inpainting_blender.py

@@ -0,0 +1,485 @@
+import logging
+from typing import Any, Dict, Optional, Tuple
+
+import cv2
+import numpy as np
+from PIL import Image
+
+logger = logging.getLogger(__name__)
+logger.setLevel(logging.INFO)
+
+
+class InpaintingBlender:
+    """
+    Handles mask processing, prompt enhancement, and result blending for inpainting.
+
+    This class encapsulates all pre-processing and post-processing operations
+    needed for inpainting, separate from the main generation pipeline.
+
+    Attributes:
+        min_mask_coverage: Minimum mask coverage threshold
+        max_mask_coverage: Maximum mask coverage threshold
+
+    Example:
+        >>> blender = InpaintingBlender()
+        >>> processed_mask, info = blender.prepare_mask(mask, (512, 512), feather_radius=8)
+        >>> enhanced_prompt, negative = blender.enhance_prompt("a flower", image, mask)
+        >>> result = blender.blend_result(original, generated, mask)
+    """
+
+    def __init__(
+        self,
+        min_mask_coverage: float = 0.01,
+        max_mask_coverage: float = 0.95
+    ):
+        """
+        Initialize the InpaintingBlender.
+
+        Parameters
+        ----------
+        min_mask_coverage : float
+            Minimum mask coverage (default: 1%)
+        max_mask_coverage : float
+            Maximum mask coverage (default: 95%)
+        """
+        self.min_mask_coverage = min_mask_coverage
+        self.max_mask_coverage = max_mask_coverage
+        logger.info("InpaintingBlender initialized")
+
+    def prepare_mask(
+        self,
+        mask: Image.Image,
+        target_size: Tuple[int, int],
+        feather_radius: int = 8
+    ) -> Tuple[Image.Image, Dict[str, Any]]:
+        """
+        Prepare and validate mask for inpainting.
+
+        Parameters
+        ----------
+        mask : PIL.Image
+            Input mask (white = inpaint area)
+        target_size : tuple
+            Target (width, height) to match input image
+        feather_radius : int
+            Feathering radius in pixels
+
+        Returns
+        -------
+        tuple
+            (processed_mask, validation_info)
+
+        Raises
+        ------
+        ValueError
+            If mask coverage is outside acceptable range
+        """
+        # Convert to grayscale
+        if mask.mode != 'L':
+            mask = mask.convert('L')
+
+        # Resize to match target
+        if mask.size != target_size:
+            mask = mask.resize(target_size, Image.LANCZOS)
+
+        # Convert to array for processing
+        mask_array = np.array(mask)
+
+        # Calculate coverage
+        total_pixels = mask_array.size
+        white_pixels = np.count_nonzero(mask_array > 127)
+        coverage = white_pixels / total_pixels
+
+        validation_info = {
+            "coverage": coverage,
+            "white_pixels": white_pixels,
+            "total_pixels": total_pixels,
+            "feather_radius": feather_radius,
+            "valid": True,
+            "warning": ""
+        }
+
+        # Validate coverage
+        if coverage < self.min_mask_coverage:
+            validation_info["valid"] = False
+            validation_info["warning"] = (
+                f"Mask coverage too low ({coverage:.1%}). "
+                f"Please select a larger area to inpaint."
+            )
+            logger.warning(f"Mask coverage {coverage:.1%} below minimum {self.min_mask_coverage:.1%}")
+
+        elif coverage > self.max_mask_coverage:
+            validation_info["valid"] = False
+            validation_info["warning"] = (
+                f"Mask coverage too high ({coverage:.1%}). "
+                f"Consider using background generation instead."
+            )
+            logger.warning(f"Mask coverage {coverage:.1%} above maximum {self.max_mask_coverage:.1%}")
+
+        # Apply feathering
+        if feather_radius > 0:
+            mask_array = cv2.GaussianBlur(
+                mask_array,
+                (feather_radius * 2 + 1, feather_radius * 2 + 1),
+                feather_radius / 2
+            )
+            logger.debug(f"Applied {feather_radius}px feathering to mask")
+
+        processed_mask = Image.fromarray(mask_array, mode='L')
+
+        return processed_mask, validation_info
+
+    def enhance_prompt_for_inpainting(
+        self,
+        prompt: str,
+        image: Image.Image,
+        mask: Image.Image
+    ) -> Tuple[str, str]:
+        """
+        Enhance prompt based on non-masked region analysis.
+
+        Analyzes the surrounding context to generate appropriate
+        lighting and color descriptors.
+
+        Parameters
+        ----------
+        prompt : str
+            User-provided prompt
+        image : PIL.Image
+            Original image
+        mask : PIL.Image
+            Inpainting mask
+
+        Returns
+        -------
+        tuple
+            (enhanced_prompt, negative_prompt)
+        """
+        logger.info("Enhancing prompt for inpainting context...")
+
+        # Convert to arrays
+        img_array = np.array(image.convert('RGB'))
+        mask_array = np.array(mask.convert('L'))
+
+        # Analyze non-masked regions
+        non_masked = mask_array < 127
+
+        if not np.any(non_masked):
+            # No context available
+            enhanced_prompt = f"{prompt}, high quality, detailed, photorealistic"
+            negative_prompt = self._get_inpainting_negative_prompt()
+            return enhanced_prompt, negative_prompt
+
+        # Extract context pixels
+        context_pixels = img_array[non_masked]
+
+        # Convert to Lab for analysis
+        context_lab = cv2.cvtColor(
+            context_pixels.reshape(-1, 1, 3),
+            cv2.COLOR_RGB2LAB
+        ).reshape(-1, 3)
+
+        # Use robust statistics (median) to avoid outlier influence
+        median_l = np.median(context_lab[:, 0])
+        median_b = np.median(context_lab[:, 2])
+
+        # Analyze lighting conditions
+        lighting_descriptors = []
+
+        if median_l > 170:
+            lighting_descriptors.append("bright")
+        elif median_l > 130:
+            lighting_descriptors.append("well-lit")
+        elif median_l > 80:
+            lighting_descriptors.append("moderate lighting")
+        else:
+            lighting_descriptors.append("dim lighting")
+
+        # Analyze color temperature (b channel: blue(-) to yellow(+))
+        if median_b > 140:
+            lighting_descriptors.append("warm golden tones")
+        elif median_b > 120:
+            lighting_descriptors.append("warm afternoon light")
+        elif median_b < 110:
+            lighting_descriptors.append("cool neutral tones")
+
+        # Calculate saturation from context
+        hsv = cv2.cvtColor(context_pixels.reshape(-1, 1, 3), cv2.COLOR_RGB2HSV)
+        median_saturation = np.median(hsv[:, :, 1])
+
+        if median_saturation > 150:
+            lighting_descriptors.append("vibrant colors")
+        elif median_saturation < 80:
+            lighting_descriptors.append("subtle muted colors")
+
+        # Build enhanced prompt
+        lighting_desc = ", ".join(lighting_descriptors) if lighting_descriptors else ""
+        quality_suffix = "high quality, detailed, photorealistic, seamless integration"
+
+        if lighting_desc:
+            enhanced_prompt = f"{prompt}, {lighting_desc}, {quality_suffix}"
+        else:
+            enhanced_prompt = f"{prompt}, {quality_suffix}"
+
+        negative_prompt = self._get_inpainting_negative_prompt()
+
+        logger.info(f"Enhanced prompt with context: {lighting_desc}")
+
+        return enhanced_prompt, negative_prompt
+
+    def _get_inpainting_negative_prompt(self) -> str:
+        """Get standard negative prompt for inpainting."""
+        return (
+            "inconsistent lighting, wrong perspective, mismatched colors, "
+            "visible seams, blending artifacts, color bleeding, "
+            "blurry, low quality, distorted, deformed, "
+            "harsh edges, unnatural transition"
+        )
+
+    def blend_result(
+        self,
+        original: Image.Image,
+        generated: Image.Image,
+        mask: Image.Image
+    ) -> Image.Image:
+        """
+        Blend generated content with original image.
+
+        Uses color matching and linear color space blending for seamless results.
+
+        Parameters
+        ----------
+        original : PIL.Image
+            Original image
+        generated : PIL.Image
+            Generated inpainted image
+        mask : PIL.Image
+            Blending mask (white = use generated)
+
+        Returns
+        -------
+        PIL.Image
+            Blended result
+        """
+        logger.info("Blending inpainting result with color matching...")
+
+        # Ensure same size
+        if generated.size != original.size:
+            generated = generated.resize(original.size, Image.LANCZOS)
+        if mask.size != original.size:
+            mask = mask.resize(original.size, Image.LANCZOS)
+
+        # Convert to arrays
+        orig_array = np.array(original.convert('RGB')).astype(np.float32)
+        gen_array = np.array(generated.convert('RGB')).astype(np.float32)
+        mask_array = np.array(mask.convert('L')).astype(np.float32) / 255.0
+
+        # Apply color matching to generated region (use original mask for accurate boundary detection)
+        gen_array = self._match_colors_at_boundary(orig_array, gen_array, mask_array)
+
+        # Create blend mask: soften edges ONLY for blending (not for generation)
+        # This ensures full generation coverage while smooth blending at edges
+        blend_mask = self._create_blend_mask(mask_array)
+
+        # sRGB to linear conversion
+        def srgb_to_linear(img: np.ndarray) -> np.ndarray:
+            img_norm = img / 255.0
+            return np.where(
+                img_norm <= 0.04045,
+                img_norm / 12.92,
+                np.power((img_norm + 0.055) / 1.055, 2.4)
+            )
+
+        def linear_to_srgb(img: np.ndarray) -> np.ndarray:
+            img_clipped = np.clip(img, 0, 1)
+            return np.where(
+                img_clipped <= 0.0031308,
+                12.92 * img_clipped,
+                1.055 * np.power(img_clipped, 1/2.4) - 0.055
+            )
+
+        # Convert to linear space
+        orig_linear = srgb_to_linear(orig_array)
+        gen_linear = srgb_to_linear(gen_array)
+
+        # Alpha blending in linear space using the blend mask (with softened edges)
+        alpha = blend_mask[:, :, np.newaxis]
+        result_linear = gen_linear * alpha + orig_linear * (1 - alpha)
+
+        # Convert back to sRGB
+        result_srgb = linear_to_srgb(result_linear)
+        result_array = (result_srgb * 255).astype(np.uint8)
+
+        logger.debug("Blending completed with color matching")
+
+        return Image.fromarray(result_array)
+
+    def _match_colors_at_boundary(
+        self,
+        original: np.ndarray,
+        generated: np.ndarray,
+        mask: np.ndarray
+    ) -> np.ndarray:
+        """
+        Match colors of generated content to original at the boundary.
+
+        Uses histogram matching in Lab color space for natural blending.
+
+        Parameters
+        ----------
+        original : np.ndarray
+            Original image array (float32, 0-255)
+        generated : np.ndarray
+            Generated image array (float32, 0-255)
+        mask : np.ndarray
+            Mask array (float32, 0-1)
+
+        Returns
+        -------
+        np.ndarray
+            Color-matched generated image
+        """
+        # Create boundary region mask (dilated mask - eroded mask)
+        mask_binary = (mask > 0.5).astype(np.uint8) * 255
+
+        # Create narrow boundary region for sampling original colors
+        kernel_size = 25  # Pixels to sample around boundary
+        kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (kernel_size, kernel_size))
+        dilated = cv2.dilate(mask_binary, kernel, iterations=1)
+        eroded = cv2.erode(mask_binary, kernel, iterations=1)
+
+        # Outer boundary (original side)
+        outer_boundary = (dilated > 0) & (mask_binary == 0)
+        # Inner boundary (generated side)
+        inner_boundary = (mask_binary > 0) & (eroded == 0)
+
+        if not np.any(outer_boundary) or not np.any(inner_boundary):
+            logger.debug("No boundary region found, skipping color matching")
+            return generated
+
+        # Convert to Lab color space
+        orig_lab = cv2.cvtColor(original.astype(np.uint8), cv2.COLOR_RGB2LAB).astype(np.float32)
+        gen_lab = cv2.cvtColor(generated.astype(np.uint8), cv2.COLOR_RGB2LAB).astype(np.float32)
+
+        # Sample colors from boundary regions
+        orig_boundary_pixels = orig_lab[outer_boundary]
+        gen_boundary_pixels = gen_lab[inner_boundary]
+
+        if len(orig_boundary_pixels) < 10 or len(gen_boundary_pixels) < 10:
+            logger.debug("Not enough boundary pixels, skipping color matching")
+            return generated
+
+        # Calculate statistics
+        orig_mean = np.mean(orig_boundary_pixels, axis=0)
+        orig_std = np.std(orig_boundary_pixels, axis=0) + 1e-6
+
+        gen_mean = np.mean(gen_boundary_pixels, axis=0)
+        gen_std = np.std(gen_boundary_pixels, axis=0) + 1e-6
+
+        # Calculate correction factors
+        # Only correct L (lightness) and a,b (color) channels
+        l_correction = (orig_mean[0] - gen_mean[0]) * 0.7  # 70% correction for lightness
+        a_correction = (orig_mean[1] - gen_mean[1]) * 0.5  # 50% correction for color
+        b_correction = (orig_mean[2] - gen_mean[2]) * 0.5
+
+        logger.debug(f"Color correction: L={l_correction:.1f}, a={a_correction:.1f}, b={b_correction:.1f}")
+
+        # Apply correction to masked region only
+        corrected_lab = gen_lab.copy()
+        mask_region = mask > 0.3  # Apply to most of masked region
+
+        corrected_lab[mask_region, 0] = np.clip(
+            corrected_lab[mask_region, 0] + l_correction, 0, 255
+        )
+        corrected_lab[mask_region, 1] = np.clip(
+            corrected_lab[mask_region, 1] + a_correction, 0, 255
+        )
+        corrected_lab[mask_region, 2] = np.clip(
+            corrected_lab[mask_region, 2] + b_correction, 0, 255
+        )
+
+        # Convert back to RGB
+        corrected_rgb = cv2.cvtColor(
+            corrected_lab.astype(np.uint8),
+            cv2.COLOR_LAB2RGB
+        ).astype(np.float32)
+
+        logger.info("Applied boundary color matching")
+
+        return corrected_rgb
+
+    def _create_blend_mask(self, mask: np.ndarray) -> np.ndarray:
+        """
+        Create a blend mask with softened edges for natural compositing.
+
+        The mask interior stays fully opaque (1.0) while only the edges
+        get a smooth transition. This preserves full generated content
+        while blending naturally at boundaries.
+
+        Parameters
+        ----------
+        mask : np.ndarray
+            Original mask array (float32, 0-1)
+
+        Returns
+        -------
+        np.ndarray
+            Blend mask with soft edges but solid interior
+        """
+        # Convert to uint8 for morphological operations
+        mask_uint8 = (mask * 255).astype(np.uint8)
+
+        # Create eroded version (solid interior)
+        kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (15, 15))
+        eroded = cv2.erode(mask_uint8, kernel, iterations=1)
+
+        # Create smooth transition zone at edges only
+        # Blur the original mask for edge softness
+        blurred = cv2.GaussianBlur(mask_uint8, (15, 15), 4)
+
+        # Combine: use eroded (solid) for interior, blurred for edges
+        # Where eroded > 0, use full opacity; elsewhere use blurred transition
+        result = np.where(eroded > 128, mask_uint8, blurred)
+
+        # Final light smoothing
+        result = cv2.GaussianBlur(result, (5, 5), 1)
+
+        # Convert back to float
+        blend_mask = result.astype(np.float32) / 255.0
+
+        logger.debug("Created blend mask with soft edges and solid interior")
+
+        return blend_mask
+
+    def validate_inputs(
+        self,
+        image: Image.Image,
+        mask: Image.Image
+    ) -> Tuple[bool, str]:
+        """
+        Validate image and mask inputs before processing.
+
+        Parameters
+        ----------
+        image : PIL.Image
+            Input image
+        mask : PIL.Image
+            Input mask
+
+        Returns
+        -------
+        tuple
+            (is_valid, error_message)
+        """
+        if image is None:
+            return False, "No image provided"
+
+        if mask is None:
+            return False, "No mask provided"
+
+        # Check sizes match
+        if image.size != mask.size:
+            # Will be resized later, so just log a warning
+            logger.warning(f"Image size {image.size} != mask size {mask.size}, will resize")
+
+        return True, ""

inpainting_models.py

@@ -0,0 +1,398 @@
+import gc
+import logging
+from dataclasses import dataclass
+from enum import Enum
+from typing import Any, Dict, Optional, Tuple
+from diffusers import StableDiffusionXLControlNetInpaintPipeline
+import torch
+
+logger = logging.getLogger(__name__)
+logger.setLevel(logging.INFO)
+
+
+class ImageMode(Enum):
+    """Image style modes for model selection."""
+    PHOTO = "photo"
+    ANIME = "anime"
+
+
+@dataclass
+class ModelConfig:
+    """Configuration for an inpainting model."""
+
+    model_id: str
+    name: str
+    description: str
+    mode: ImageMode
+    requires_variant: bool = True
+    variant: str = "fp16"
+    recommended_for: str = ""
+
+    # Model-specific settings
+    default_guidance_scale: float = 7.5
+    default_num_inference_steps: int = 25
+
+
+class InpaintingModelManager:
+    """
+    Manages multiple inpainting models for different image styles.
+
+    Provides lazy loading and switching between models optimized for
+    photorealistic images vs anime/illustration styles.
+
+    Attributes:
+        AVAILABLE_MODELS: Dictionary of all supported models
+        current_model: Currently loaded model identifier
+
+    Example:
+        >>> manager = InpaintingModelManager(device="cuda")
+        >>> pipeline = manager.get_pipeline(ImageMode.PHOTO)
+        >>> # Use pipeline for inpainting
+        >>> manager.switch_model(ImageMode.ANIME)
+    """
+
+    # Available models configuration
+    AVAILABLE_MODELS: Dict[str, ModelConfig] = {
+        # Photo-realistic models
+        "juggernaut_xl": ModelConfig(
+            model_id="RunDiffusion/Juggernaut-XL-v9",
+            name="JuggernautXL v9",
+            description="Best for photorealistic images, portraits, and real photos",
+            mode=ImageMode.PHOTO,
+            requires_variant=True,
+            variant="fp16",
+            recommended_for="Real photos, portraits, professional photography",
+            default_guidance_scale=7.0,
+            default_num_inference_steps=25
+        ),
+        "realvis_xl": ModelConfig(
+            model_id="SG161222/RealVisXL_V4.0",
+            name="RealVisXL v4",
+            description="Excellent for realistic images with fine details",
+            mode=ImageMode.PHOTO,
+            requires_variant=True,
+            variant="fp16",
+            recommended_for="Realistic scenes, product photos, nature",
+            default_guidance_scale=7.0,
+            default_num_inference_steps=25
+        ),
+        # Anime/Illustration models
+        "sdxl_base": ModelConfig(
+            model_id="stabilityai/stable-diffusion-xl-base-1.0",
+            name="SDXL Base",
+            description="Versatile model for general use and illustrations",
+            mode=ImageMode.ANIME,
+            requires_variant=True,
+            variant="fp16",
+            recommended_for="General illustrations, digital art, versatile use",
+            default_guidance_scale=7.5,
+            default_num_inference_steps=25
+        ),
+        "animagine_xl": ModelConfig(
+            model_id="cagliostrolab/animagine-xl-3.1",
+            name="Animagine XL 3.1",
+            description="Specialized for anime and manga style images",
+            mode=ImageMode.ANIME,
+            requires_variant=False,
+            recommended_for="Anime, manga, cartoon style images",
+            default_guidance_scale=7.0,
+            default_num_inference_steps=25
+        ),
+    }
+
+    # Default model for each mode
+    DEFAULT_MODELS = {
+        ImageMode.PHOTO: "juggernaut_xl",
+        ImageMode.ANIME: "sdxl_base"
+    }
+
+    def __init__(self, device: Optional[str] = None):
+        """
+        Initialize the model manager.
+
+        Parameters
+        ----------
+        device : str, optional
+            Device to load models on. Auto-detected if not specified.
+        """
+        self.device = device or self._detect_device()
+        self._current_model_key: Optional[str] = None
+        self._pipeline: Optional[Any] = None
+        self._controlnet: Optional[Any] = None
+        self._controlnet_loaded: bool = False
+
+        logger.info(f"InpaintingModelManager initialized on device: {self.device}")
+
+    def _detect_device(self) -> str:
+        """Detect the best available device."""
+        if torch.cuda.is_available():
+            return "cuda"
+        elif hasattr(torch.backends, "mps") and torch.backends.mps.is_available():
+            return "mps"
+        return "cpu"
+
+    def get_models_for_mode(self, mode: ImageMode) -> Dict[str, ModelConfig]:
+        """
+        Get all available models for a specific mode.
+
+        Parameters
+        ----------
+        mode : ImageMode
+            The image mode (PHOTO or ANIME)
+
+        Returns
+        -------
+        dict
+            Dictionary of model configs for the mode
+        """
+        return {
+            key: config
+            for key, config in self.AVAILABLE_MODELS.items()
+            if config.mode == mode
+        }
+
+    def get_model_choices(self) -> Dict[str, list]:
+        """
+        Get model choices formatted for UI dropdown.
+
+        Returns
+        -------
+        dict
+            Dictionary with 'photo' and 'anime' lists of (display_name, key) tuples
+        """
+        choices = {
+            "photo": [],
+            "anime": []
+        }
+
+        for key, config in self.AVAILABLE_MODELS.items():
+            display = f"{config.name} - {config.description}"
+            if config.mode == ImageMode.PHOTO:
+                choices["photo"].append((display, key))
+            else:
+                choices["anime"].append((display, key))
+
+        return choices
+
+    def get_default_model(self, mode: ImageMode) -> str:
+        """Get the default model key for a mode."""
+        return self.DEFAULT_MODELS.get(mode, "sdxl_base")
+
+    def load_controlnet(self) -> Any:
+        """
+        Load the ControlNet model (shared across all base models).
+
+        Returns
+        -------
+        ControlNetModel
+            Loaded ControlNet model
+        """
+        if self._controlnet_loaded and self._controlnet is not None:
+            return self._controlnet
+
+        try:
+            from diffusers import ControlNetModel
+
+            logger.info("Loading ControlNet Canny model...")
+            self._controlnet = ControlNetModel.from_pretrained(
+                "diffusers/controlnet-canny-sdxl-1.0",
+                torch_dtype=torch.float16 if self.device == "cuda" else torch.float32,
+                use_safetensors=True
+            )
+            self._controlnet_loaded = True
+            logger.info("ControlNet loaded successfully")
+            return self._controlnet
+
+        except Exception as e:
+            logger.error(f"Failed to load ControlNet: {e}")
+            raise
+
+    def load_pipeline(
+        self,
+        model_key: Optional[str] = None,
+        mode: Optional[ImageMode] = None
+    ) -> Any:
+        """
+        Load an inpainting pipeline for the specified model.
+
+        Parameters
+        ----------
+        model_key : str, optional
+            Specific model key to load
+        mode : ImageMode, optional
+            If model_key not specified, load default for this mode
+
+        Returns
+        -------
+        StableDiffusionXLControlNetInpaintPipeline
+            Loaded pipeline ready for inference
+        """
+        # Determine which model to load
+        if model_key is None:
+            if mode is None:
+                mode = ImageMode.PHOTO
+            model_key = self.get_default_model(mode)
+
+        # Check if already loaded
+        if self._current_model_key == model_key and self._pipeline is not None:
+            logger.info(f"Model {model_key} already loaded")
+            return self._pipeline
+
+        # Unload current model if different
+        if self._current_model_key != model_key:
+            self.unload_pipeline()
+
+        # Get model config
+        config = self.AVAILABLE_MODELS.get(model_key)
+        if config is None:
+            raise ValueError(f"Unknown model key: {model_key}")
+
+        logger.info(f"Loading model: {config.name} ({config.model_id})")
+
+        try:
+            # Ensure ControlNet is loaded
+            controlnet = self.load_controlnet()
+
+            # Load pipeline
+            dtype = torch.float16 if self.device == "cuda" else torch.float32
+
+            load_kwargs = {
+                "controlnet": controlnet,
+                "torch_dtype": dtype,
+                "use_safetensors": True,
+            }
+
+            if config.requires_variant:
+                load_kwargs["variant"] = config.variant
+
+            self._pipeline = StableDiffusionXLControlNetInpaintPipeline.from_pretrained(
+                config.model_id,
+                **load_kwargs
+            )
+
+            # Move to device and optimize
+            self._pipeline = self._pipeline.to(self.device)
+
+            if self.device == "cuda":
+                self._pipeline.enable_vae_tiling()
+                try:
+                    self._pipeline.enable_xformers_memory_efficient_attention()
+                    logger.info("xformers enabled")
+                except Exception:
+                    logger.info("xformers not available, using default attention")
+
+            self._current_model_key = model_key
+            logger.info(f"Model {config.name} loaded successfully")
+
+            return self._pipeline
+
+        except Exception as e:
+            logger.error(f"Failed to load model {model_key}: {e}")
+            raise
+
+    def unload_pipeline(self) -> None:
+        """Unload the current pipeline to free memory."""
+        if self._pipeline is not None:
+            logger.info(f"Unloading model: {self._current_model_key}")
+            del self._pipeline
+            self._pipeline = None
+            self._current_model_key = None
+
+            if self.device == "cuda":
+                torch.cuda.empty_cache()
+            gc.collect()
+
+    def switch_model(self, model_key: str) -> Any:
+        """
+        Switch to a different model.
+
+        Parameters
+        ----------
+        model_key : str
+            Model key to switch to
+
+        Returns
+        -------
+        Pipeline
+            Newly loaded pipeline
+        """
+        return self.load_pipeline(model_key=model_key)
+
+    def get_current_model_config(self) -> Optional[ModelConfig]:
+        """Get the configuration of the currently loaded model."""
+        if self._current_model_key is None:
+            return None
+        return self.AVAILABLE_MODELS.get(self._current_model_key)
+
+    def get_pipeline(self) -> Optional[Any]:
+        """Get the currently loaded pipeline."""
+        return self._pipeline
+
+    def is_loaded(self) -> bool:
+        """Check if a pipeline is currently loaded."""
+        return self._pipeline is not None
+
+    def get_status(self) -> Dict[str, Any]:
+        """
+        Get current status of the model manager.
+
+        Returns
+        -------
+        dict
+            Status information
+        """
+        current_config = self.get_current_model_config()
+        return {
+            "device": self.device,
+            "current_model": self._current_model_key,
+            "current_model_name": current_config.name if current_config else None,
+            "is_loaded": self.is_loaded(),
+            "controlnet_loaded": self._controlnet_loaded,
+            "available_models": list(self.AVAILABLE_MODELS.keys())
+        }
+
+
+def get_model_selection_guide() -> str:
+    """
+    Get HTML guide for model selection to display in UI.
+
+    Returns
+    -------
+    str
+        HTML formatted guide
+    """
+    return """
+    <div style="background: linear-gradient(135deg, #f5f7fa 0%, #e4e8ec 100%);
+                padding: 16px;
+                border-radius: 12px;
+                margin: 12px 0;
+                border: 1px solid #ddd;">
+        <h4 style="margin: 0 0 12px 0; color: #333; font-size: 16px;">
+            📸 Model Selection Guide
+        </h4>
+        <div style="display: grid; grid-template-columns: 1fr 1fr; gap: 12px;">
+            <div style="background: white; padding: 12px; border-radius: 8px; border-left: 4px solid #4CAF50;">
+                <p style="margin: 0 0 8px 0; font-weight: bold; color: #4CAF50;">
+                    🖼️ Photo Mode
+                </p>
+                <p style="margin: 0; font-size: 13px; color: #555;">
+                    <strong>Best for:</strong> Real photographs, portraits, product shots, nature photos
+                </p>
+                <p style="margin: 8px 0 0 0; font-size: 12px; color: #777;">
+                    Recommended: JuggernautXL for portraits, RealVisXL for scenes
+                </p>
+            </div>
+            <div style="background: white; padding: 12px; border-radius: 8px; border-left: 4px solid #9C27B0;">
+                <p style="margin: 0 0 8px 0; font-weight: bold; color: #9C27B0;">
+                    🎨 Anime Mode
+                </p>
+                <p style="margin: 0; font-size: 13px; color: #555;">
+                    <strong>Best for:</strong> Anime, manga, illustrations, digital art, cartoons
+                </p>
+                <p style="margin: 8px 0 0 0; font-size: 12px; color: #777;">
+                    Recommended: Animagine XL for anime, SDXL Base for general art
+                </p>
+            </div>
+        </div>
+    </div>
+    """

inpainting_module.py

@@ -4,55 +4,57 @@ import os
 import time
 import traceback
 from dataclasses import dataclass, field
-from typing import Any, Callable, Dict, List, Optional, Tuple, Union
+from typing import Any, Callable, Dict, Optional, Tuple
 
 import cv2
 import numpy as np
 import torch
-from PIL import Image, ImageFilter
+from PIL import Image
 
-from diffusers import ControlNetModel, DPMSolverMultistepScheduler
+from diffusers import AutoPipelineForInpainting
+from diffusers import ControlNetModel
+from diffusers import DPMSolverMultistepScheduler
 from diffusers import StableDiffusionXLControlNetInpaintPipeline
-from diffusers import StableDiffusionXLInpaintPipeline
-from transformers import AutoImageProcessor, AutoModelForDepthEstimation
-from transformers import DPTImageProcessor, DPTForDepthEstimation
+from transformers import AutoImageProcessor
+from transformers import AutoModelForDepthEstimation
+from transformers import DPTForDepthEstimation
+from transformers import DPTImageProcessor
+
+from control_image_processor import ControlImageProcessor
+from inpainting_blender import InpaintingBlender
 
 logger = logging.getLogger(__name__)
 logger.setLevel(logging.INFO)
 
 
+# Dedicated SDXL Inpainting model - trained specifically for inpainting
+SDXL_INPAINTING_MODEL = "diffusers/stable-diffusion-xl-1.0-inpainting-0.1"
+
+
 @dataclass
 class InpaintingConfig:
     """Configuration for inpainting operations."""
 
-    # ControlNet settings
+    # ControlNet settings (for ControlNet mode only)
     controlnet_conditioning_scale: float = 0.7
-    conditioning_type: str = "canny"  # "canny" or "depth"
+    conditioning_type: str = "canny"
 
     # Canny edge detection parameters
     canny_low_threshold: int = 100
     canny_high_threshold: int = 200
 
     # Mask settings
-    feather_radius: int = 8
+    feather_radius: int = 3
     min_mask_coverage: float = 0.01
     max_mask_coverage: float = 0.95
 
     # Generation settings
     num_inference_steps: int = 25
     guidance_scale: float = 7.5
-    strength: float = 1.0  # Inpainting strength (0.0-1.0), 1.0 = full repaint
-    preview_steps: int = 15
-    preview_guidance_scale: float = 8.0
-
-    # Quality settings
-    enable_auto_optimization: bool = True
-    max_optimization_retries: int = 3
-    min_quality_score: float = 70.0
+    strength: float = 0.99  # Use 0.99 to avoid noise issues with 1.0
 
     # Memory settings
     enable_vae_tiling: bool = True
-    enable_attention_slicing: bool = True
     max_resolution: int = 1024
 
 
@@ -66,94 +68,81 @@ class InpaintingResult:
     control_image: Optional[Image.Image] = None
     blended_image: Optional[Image.Image] = None
     quality_score: float = 0.0
-    quality_details: Dict[str, Any] = field(default_factory=dict)
     generation_time: float = 0.0
-    retries: int = 0
     error_message: str = ""
     metadata: Dict[str, Any] = field(default_factory=dict)
 
 
 class InpaintingModule:
     """
-    ControlNet-based Inpainting Module for SceneWeaver.
+    Dual-mode Inpainting Module for SceneWeaver.
 
-    Implements StableDiffusionXLControlNetInpaintPipeline with support for
-    Canny edge and depth map conditioning. Features two-stage generation
-    (preview + full quality) and automatic quality optimization.
+    Supports two modes:
+    1. Pure Inpainting (use_controlnet=False): Uses dedicated SDXL Inpainting model
+       - Best for: Object replacement, Object removal
+       - More stable, better edge blending
 
-    Attributes:
-        device: Computation device (cuda/mps/cpu)
-        config: InpaintingConfig instance
-        is_initialized: Whether pipeline is loaded
+    2. ControlNet Inpainting (use_controlnet=True): Uses ControlNet + SDXL
+       - Best for: Clothing change (depth), Color change (canny)
+       - Preserves structure in masked region
 
     Example:
         >>> module = InpaintingModule(device="cuda")
-        >>> module.load_inpainting_pipeline(progress_callback=my_callback)
-        >>> result = module.execute_inpainting(
-        ...     image=my_image,
-        ...     mask=my_mask,
-        ...     prompt="a beautiful garden"
-        ... )
+        >>> # For object replacement (no ControlNet)
+        >>> module.load_pipeline(use_controlnet=False)
+        >>> result = module.execute_inpainting(image, mask, "a vase with flowers")
     """
 
-    # Model identifiers
+    # ControlNet model identifiers
     CONTROLNET_CANNY_MODEL = "diffusers/controlnet-canny-sdxl-1.0"
     CONTROLNET_DEPTH_MODEL = "diffusers/controlnet-depth-sdxl-1.0"
     DEPTH_MODEL_PRIMARY = "LiheYoung/depth-anything-small-hf"
     DEPTH_MODEL_FALLBACK = "Intel/dpt-hybrid-midas"
-    BASE_MODEL = "stabilityai/stable-diffusion-xl-base-1.0"
+
+    # Base models for ControlNet mode
+    SUPPORTED_MODELS = {
+        "juggernaut_xl": "RunDiffusion/Juggernaut-XL-v9",
+        "realvis_xl": "SG161222/RealVisXL_V4.0",
+        "sdxl_base": "stabilityai/stable-diffusion-xl-base-1.0",
+        "animagine_xl": "cagliostrolab/animagine-xl-3.1",
+    }
 
     def __init__(
         self,
         device: str = "auto",
         config: Optional[InpaintingConfig] = None
     ):
-        """
-        Initialize the InpaintingModule.
-
-        Parameters
-        ----------
-        device : str, optional
-            Computation device. "auto" for automatic detection.
-        config : InpaintingConfig, optional
-            Configuration object. Uses defaults if not provided.
-        """
+        """Initialize the InpaintingModule."""
         self.device = self._setup_device(device)
         self.config = config or InpaintingConfig()
 
-        # Pipeline instances (lazy loaded)
-        self._inpaint_pipeline = None
-        self._controlnet_canny = None
-        self._controlnet_depth = None
+        # Sub-modules
+        self._control_processor = ControlImageProcessor(
+            device=self.device,
+            canny_low_threshold=self.config.canny_low_threshold,
+            canny_high_threshold=self.config.canny_high_threshold
+        )
+        self._blender = InpaintingBlender(
+            min_mask_coverage=self.config.min_mask_coverage,
+            max_mask_coverage=self.config.max_mask_coverage
+        )
+
+        # Pipeline instances
+        self._pipeline = None
+        self._controlnet = None
         self._depth_estimator = None
         self._depth_processor = None
 
         # State tracking
         self.is_initialized = False
+        self._current_mode = None  # "pure" or "controlnet"
         self._current_conditioning_type = None
-        self._last_seed = None
-        self._cached_latents = None
-        self._use_controlnet = True  # Track if ControlNet is available
-
-        # Reference to model manager (set by SceneWeaverCore)
-        self._model_manager = None
+        self._current_model_key = None
 
         logger.info(f"InpaintingModule initialized on {self.device}")
 
     def _setup_device(self, device: str) -> str:
-        """
-        Setup computation device.
-
-        Parameters
-        ----------
-        device : str
-            Device specification or "auto"
-
-        Returns
-        -------
-        str
-            Resolved device name
-        """
+        """Setup computation device."""
         if device == "auto":
             if torch.cuda.is_available():
                 return "cuda"
@@ -162,224 +151,159 @@ class InpaintingModule:
             return "cpu"
         return device
 
-    def set_model_manager(self, manager: Any) -> None:
-        """
-        Set reference to ModelManager for coordinated model lifecycle.
-
-        Parameters
-        ----------
-        manager : ModelManager
-            The global model manager instance
-        """
-        self._model_manager = manager
-        logger.info("ModelManager reference set for InpaintingModule")
-
     def _memory_cleanup(self, aggressive: bool = False) -> None:
-        """
-        Perform memory cleanup.
-
-        Parameters
-        ----------
-        aggressive : bool
-            If True, perform multiple GC rounds and sync CUDA
-        """
-        rounds = 5 if aggressive else 2
-        for _ in range(rounds):
+        """Perform memory cleanup."""
+        for _ in range(5 if aggressive else 2):
             gc.collect()
 
-        # On Hugging Face Spaces, avoid CUDA operations in main process
-        # CUDA operations must only happen within @spaces.GPU decorated functions
         is_spaces = os.getenv('SPACE_ID') is not None
-
         if not is_spaces and torch.cuda.is_available():
             torch.cuda.empty_cache()
             if aggressive:
                 torch.cuda.ipc_collect()
-                torch.cuda.synchronize()
-
-        logger.debug(f"Memory cleanup completed (aggressive={aggressive}, spaces={is_spaces})")
-
-    def _check_memory_status(self) -> Dict[str, float]:
-        """
-        Check current GPU memory status.
-
-        Returns
-        -------
-        dict
-            Memory statistics including allocated, total, and usage ratio
-        """
-        # On Spaces, skip CUDA checks in main process
-        is_spaces = os.getenv('SPACE_ID') is not None
-
-        if is_spaces or not torch.cuda.is_available():
-            return {"available": True, "usage_ratio": 0.0}
 
-        allocated = torch.cuda.memory_allocated() / 1024**3
-        total = torch.cuda.get_device_properties(0).total_memory / 1024**3
-        usage_ratio = allocated / total
-
-        return {
-            "allocated_gb": round(allocated, 2),
-            "total_gb": round(total, 2),
-            "free_gb": round(total - allocated, 2),
-            "usage_ratio": round(usage_ratio, 3),
-            "available": usage_ratio < 0.9
-        }
-
-    def load_inpainting_pipeline(
+    def load_pipeline(
         self,
+        use_controlnet: bool = False,
         conditioning_type: str = "canny",
+        model_key: str = "sdxl_base",
         progress_callback: Optional[Callable[[str, int], None]] = None
     ) -> Tuple[bool, str]:
         """
-        Load the ControlNet inpainting pipeline.
-
-        Implements mutual exclusion with background generation pipeline.
-        Only one pipeline can be loaded at a time.
+        Load the appropriate inpainting pipeline.
 
         Parameters
         ----------
+        use_controlnet : bool
+            If False, use dedicated SDXL Inpainting model (for replacement/removal)
+            If True, use ControlNet pipeline (for clothing/color change)
         conditioning_type : str
-            Type of ControlNet conditioning: "canny" or "depth"
+            ControlNet type: "canny" or "depth" (only used when use_controlnet=True)
+        model_key : str
+            Base model for ControlNet mode
         progress_callback : callable, optional
-            Function(message, percentage) for progress updates
+            Progress update function
 
         Returns
         -------
         tuple
             (success: bool, error_message: str)
         """
-        if self.is_initialized and self._current_conditioning_type == conditioning_type:
-            logger.info(f"Inpainting pipeline already loaded with {conditioning_type}")
+        mode = "controlnet" if use_controlnet else "pure"
+
+        # Check if already loaded with same config
+        if (self.is_initialized and
+            self._current_mode == mode and
+            (not use_controlnet or
+             (self._current_conditioning_type == conditioning_type and
+              self._current_model_key == model_key))):
+            logger.info(f"Pipeline already loaded: mode={mode}")
             return True, ""
 
-        logger.info(f"Loading inpainting pipeline with {conditioning_type} conditioning...")
+        logger.info(f"Loading pipeline: mode={mode}, conditioning={conditioning_type}")
 
         try:
             self._memory_cleanup(aggressive=True)
 
             if progress_callback:
-                progress_callback("Preparing to load inpainting models...", 5)
+                progress_callback("Preparing pipeline...", 10)
+
+            # Unload existing pipeline
+            self._unload_pipeline()
 
-            # Unload existing pipeline if different conditioning type
-            if self._inpaint_pipeline is not None:
-                self._unload_pipeline()
+            dtype = torch.float16 if self.device == "cuda" else torch.float32
 
-            # Use ControlNet inpainting by default
-            use_controlnet_inpaint = True
-            logger.info("Using StableDiffusionXLControlNetInpaintPipeline")
+            if not use_controlnet:
+                # Mode A: Pure SDXL Inpainting (for replacement/removal)
+                if progress_callback:
+                    progress_callback("Loading SDXL Inpainting model...", 30)
 
-            if progress_callback:
-                progress_callback("Loading ControlNet model...", 20)
+                self._pipeline = AutoPipelineForInpainting.from_pretrained(
+                    SDXL_INPAINTING_MODEL,
+                    torch_dtype=dtype,
+                    variant="fp16" if dtype == torch.float16 else None,
+                )
+                self._current_mode = "pure"
+                self._current_conditioning_type = None
+                logger.info("Loaded pure SDXL Inpainting pipeline")
 
-            # Load appropriate ControlNet
-            dtype = torch.float16 if self.device == "cuda" else torch.float32
-            controlnet = None
+            else:
+                # Mode B: ControlNet Inpainting (for structure-preserving tasks)
+                if model_key not in self.SUPPORTED_MODELS:
+                    model_key = "sdxl_base"
+                base_model_id = self.SUPPORTED_MODELS[model_key]
 
-            if use_controlnet_inpaint:
+                if progress_callback:
+                    progress_callback("Loading ControlNet model...", 30)
+
+                # Load ControlNet
                 if conditioning_type == "canny":
-                    controlnet = ControlNetModel.from_pretrained(
+                    self._controlnet = ControlNetModel.from_pretrained(
                         self.CONTROLNET_CANNY_MODEL,
                         torch_dtype=dtype,
                         use_safetensors=True
                     )
-                    self._controlnet_canny = controlnet
-                    logger.info("Loaded ControlNet Canny model")
-
                 elif conditioning_type == "depth":
-                    controlnet = ControlNetModel.from_pretrained(
+                    self._controlnet = ControlNetModel.from_pretrained(
                         self.CONTROLNET_DEPTH_MODEL,
                         torch_dtype=dtype,
                         use_safetensors=True
                     )
-                    self._controlnet_depth = controlnet
-
-                    # Load depth estimator
-                    if progress_callback:
-                        progress_callback("Loading depth estimation model...", 35)
                     self._load_depth_estimator()
-                    logger.info("Loaded ControlNet Depth model")
                 else:
                     raise ValueError(f"Unknown conditioning type: {conditioning_type}")
-            else:
-                # Skip ControlNet loading for fallback mode
-                logger.info(f"Skipping ControlNet loading (fallback mode)")
 
-            if progress_callback:
-                progress_callback("Loading SDXL Inpainting pipeline...", 50)
+                if progress_callback:
+                    progress_callback(f"Loading {model_key}...", 60)
+
+                # Load pipeline with ControlNet
+                use_variant = model_key != "animagine_xl"
+                load_kwargs = {
+                    "controlnet": self._controlnet,
+                    "torch_dtype": dtype,
+                    "use_safetensors": True,
+                }
+                if use_variant and dtype == torch.float16:
+                    load_kwargs["variant"] = "fp16"
 
-            # Load the inpainting pipeline
-            if use_controlnet_inpaint and controlnet is not None:
-                self._inpaint_pipeline = StableDiffusionXLControlNetInpaintPipeline.from_pretrained(
-                    self.BASE_MODEL,
-                    controlnet=controlnet,
-                    torch_dtype=dtype,
-                    use_safetensors=True,
-                    variant="fp16" if dtype == torch.float16 else None
+                self._pipeline = StableDiffusionXLControlNetInpaintPipeline.from_pretrained(
+                    base_model_id,
+                    **load_kwargs
                 )
-            else:
-                # Fallback: Use dedicated inpainting model without ControlNet
-                self._inpaint_pipeline = StableDiffusionXLInpaintPipeline.from_pretrained(
-                    "diffusers/stable-diffusion-xl-1.0-inpainting-0.1",
-                    torch_dtype=dtype,
-                    use_safetensors=True,
-                    variant="fp16" if dtype == torch.float16 else None
-                )
-                self._use_controlnet = False
-
-            # Track ControlNet usage
-            self._use_controlnet = use_controlnet_inpaint and controlnet is not None
+                self._current_mode = "controlnet"
+                self._current_conditioning_type = conditioning_type
+                self._current_model_key = model_key
+                logger.info(f"Loaded ControlNet pipeline: {model_key} + {conditioning_type}")
 
             if progress_callback:
-                progress_callback("Configuring scheduler...", 70)
+                progress_callback("Configuring pipeline...", 80)
 
-            # Configure scheduler for faster generation
-            self._inpaint_pipeline.scheduler = DPMSolverMultistepScheduler.from_config(
-                self._inpaint_pipeline.scheduler.config
+            # Configure scheduler
+            self._pipeline.scheduler = DPMSolverMultistepScheduler.from_config(
+                self._pipeline.scheduler.config
             )
 
-            # Move to device
-            self._inpaint_pipeline = self._inpaint_pipeline.to(self.device)
-
-            if progress_callback:
-                progress_callback("Applying optimizations...", 85)
-
-            # Apply memory optimizations
-            self._apply_pipeline_optimizations()
-
-            # Set eval mode
-            self._inpaint_pipeline.unet.eval()
-            if hasattr(self._inpaint_pipeline, 'vae'):
-                self._inpaint_pipeline.vae.eval()
+            # Move to device and optimize
+            self._pipeline = self._pipeline.to(self.device)
+            self._apply_optimizations()
 
             self.is_initialized = True
-            self._current_conditioning_type = conditioning_type if self._use_controlnet else "none"
 
             if progress_callback:
-                progress_callback("Inpainting pipeline ready!", 100)
-
-            # Log memory status
-            mem_status = self._check_memory_status()
-            logger.info(f"Pipeline loaded. GPU memory: {mem_status.get('allocated_gb', 0):.1f}GB used")
+                progress_callback("Pipeline ready!", 100)
 
             return True, ""
 
         except Exception as e:
             error_msg = str(e)
-            logger.error(f"Failed to load inpainting pipeline: {error_msg}")
+            logger.error(f"Failed to load pipeline: {error_msg}")
             traceback.print_exc()
             self._unload_pipeline()
             return False, error_msg
 
     def _load_depth_estimator(self) -> None:
-        """
-        Load depth estimation model with fallback strategy.
-
-        Tries Depth-Anything first, falls back to MiDaS if unavailable.
-        """
+        """Load depth estimation model."""
         try:
-            logger.info(f"Attempting to load depth model: {self.DEPTH_MODEL_PRIMARY}")
-
             self._depth_processor = AutoImageProcessor.from_pretrained(
                 self.DEPTH_MODEL_PRIMARY
             )
@@ -389,70 +313,50 @@ class InpaintingModule:
             )
             self._depth_estimator.to(self.device)
             self._depth_estimator.eval()
-
-            logger.info("Successfully loaded Depth-Anything model")
-
+            logger.info("Loaded Depth-Anything model")
         except Exception as e:
             logger.warning(f"Primary depth model failed: {e}, trying fallback...")
+            self._depth_processor = DPTImageProcessor.from_pretrained(
+                self.DEPTH_MODEL_FALLBACK
+            )
+            self._depth_estimator = DPTForDepthEstimation.from_pretrained(
+                self.DEPTH_MODEL_FALLBACK,
+                torch_dtype=torch.float16 if self.device == "cuda" else torch.float32
+            )
+            self._depth_estimator.to(self.device)
+            self._depth_estimator.eval()
+            logger.info("Loaded MiDaS fallback model")
 
-            try:
-                self._depth_processor = DPTImageProcessor.from_pretrained(
-                    self.DEPTH_MODEL_FALLBACK
-                )
-                self._depth_estimator = DPTForDepthEstimation.from_pretrained(
-                    self.DEPTH_MODEL_FALLBACK,
-                    torch_dtype=torch.float16 if self.device == "cuda" else torch.float32
-                )
-                self._depth_estimator.to(self.device)
-                self._depth_estimator.eval()
-
-                logger.info("Successfully loaded MiDaS fallback model")
-
-            except Exception as fallback_e:
-                logger.error(f"Fallback depth model also failed: {fallback_e}")
-                raise RuntimeError("Unable to load any depth estimation model")
-
-    def _apply_pipeline_optimizations(self) -> None:
-        """Apply memory and performance optimizations to the pipeline."""
-        if self._inpaint_pipeline is None:
+    def _apply_optimizations(self) -> None:
+        """Apply memory and performance optimizations."""
+        if self._pipeline is None:
             return
 
-        # Try xformers first
         try:
-            self._inpaint_pipeline.enable_xformers_memory_efficient_attention()
-            logger.info("Enabled xformers memory efficient attention")
+            self._pipeline.enable_xformers_memory_efficient_attention()
+            logger.info("Enabled xformers attention")
         except Exception:
             try:
-                self._inpaint_pipeline.enable_attention_slicing()
+                self._pipeline.enable_attention_slicing()
                 logger.info("Enabled attention slicing")
             except Exception:
-                logger.warning("No attention optimization available")
+                pass
 
-        # VAE optimizations
         if self.config.enable_vae_tiling:
-            if hasattr(self._inpaint_pipeline, 'enable_vae_tiling'):
-                self._inpaint_pipeline.enable_vae_tiling()
-                logger.debug("Enabled VAE tiling")
-
-        if hasattr(self._inpaint_pipeline, 'enable_vae_slicing'):
-            self._inpaint_pipeline.enable_vae_slicing()
-            logger.debug("Enabled VAE slicing")
+            if hasattr(self._pipeline, 'enable_vae_tiling'):
+                self._pipeline.enable_vae_tiling()
+            if hasattr(self._pipeline, 'enable_vae_slicing'):
+                self._pipeline.enable_vae_slicing()
 
     def _unload_pipeline(self) -> None:
-        """Unload the inpainting pipeline and free memory."""
-        logger.info("Unloading inpainting pipeline...")
+        """Unload pipeline and free memory."""
+        if self._pipeline is not None:
+            del self._pipeline
+            self._pipeline = None
 
-        if self._inpaint_pipeline is not None:
-            del self._inpaint_pipeline
-            self._inpaint_pipeline = None
-
-        if self._controlnet_canny is not None:
-            del self._controlnet_canny
-            self._controlnet_canny = None
-
-        if self._controlnet_depth is not None:
-            del self._controlnet_depth
-            self._controlnet_depth = None
+        if self._controlnet is not None:
+            del self._controlnet
+            self._controlnet = None
 
         if self._depth_estimator is not None:
             del self._depth_estimator
@@ -463,942 +367,300 @@ class InpaintingModule:
             self._depth_processor = None
 
         self.is_initialized = False
+        self._current_mode = None
         self._current_conditioning_type = None
-        self._cached_latents = None
 
         self._memory_cleanup(aggressive=True)
-        logger.info("Inpainting pipeline unloaded")
-
-    def prepare_control_image(
-        self,
-        image: Image.Image,
-        mode: str = "canny",
-        mask: Optional[Image.Image] = None,
-        preserve_structure: bool = False
-    ) -> Image.Image:
-        """
-        Generate ControlNet conditioning image.
-
-        Parameters
-        ----------
-        image : PIL.Image
-            Input image
-        mode : str
-            Conditioning mode: "canny" or "depth"
-        mask : PIL.Image, optional
-            If provided, can suppress edges in masked region (when preserve_structure=False).
-        preserve_structure : bool
-            If True, keep edges in masked region (for color change tasks).
-            If False, suppress edges in masked region (for replacement/removal tasks).
-
-        Returns
-        -------
-        PIL.Image
-            Generated control image (edges or depth map)
-        """
-        logger.info(f"Preparing control image with mode: {mode}, preserve_structure: {preserve_structure}")
-
-        # Convert to RGB if needed
-        if image.mode != 'RGB':
-            image = image.convert('RGB')
-
-        img_array = np.array(image)
-
-        if mode == "canny":
-            canny_image = self._generate_canny_edges(img_array)
-
-            # Mask-aware processing: suppress edges in masked region ONLY if not preserving structure
-            if mask is not None and not preserve_structure:
-                canny_array = np.array(canny_image)
-                mask_array = np.array(mask.convert('L'))
-
-                # In masked region, completely suppress Canny edges
-                # This allows complete replacement/removal of the object
-                mask_region = mask_array > 128  # White = masked area
-                canny_array[mask_region] = 0
-
-                canny_image = Image.fromarray(canny_array)
-                logger.info("Suppressed edges in masked region for replacement/removal")
-            elif preserve_structure:
-                logger.info("Preserving edges in masked region for color change")
-
-            return canny_image
-
-        elif mode == "depth":
-            return self._generate_depth_map(image)
-        else:
-            raise ValueError(f"Unknown control mode: {mode}")
-
-    def _generate_canny_edges(self, img_array: np.ndarray) -> Image.Image:
-        """
-        Generate Canny edge detection image.
-
-        Parameters
-        ----------
-        img_array : np.ndarray
-            Input image as RGB numpy array
-
-        Returns
-        -------
-        PIL.Image
-            Edge detection result as grayscale image
-        """
-        # Convert to grayscale
-        gray = cv2.cvtColor(img_array, cv2.COLOR_RGB2GRAY)
-
-        # Apply Gaussian blur to reduce noise
-        blurred = cv2.GaussianBlur(gray, (5, 5), 1.4)
-
-        # Canny edge detection
-        edges = cv2.Canny(
-            blurred,
-            self.config.canny_low_threshold,
-            self.config.canny_high_threshold
-        )
-
-        # Convert to 3-channel for ControlNet
-        edges_3ch = cv2.cvtColor(edges, cv2.COLOR_GRAY2RGB)
-
-        logger.debug(f"Generated Canny edges with thresholds "
-                    f"{self.config.canny_low_threshold}/{self.config.canny_high_threshold}")
-
-        return Image.fromarray(edges_3ch)
-
-    def _generate_depth_map(self, image: Image.Image) -> Image.Image:
-        """
-        Generate depth map using depth estimation model.
-
-        Parameters
-        ----------
-        image : PIL.Image
-            Input RGB image
-
-        Returns
-        -------
-        PIL.Image
-            Depth map as grayscale image
-        """
-        if self._depth_estimator is None or self._depth_processor is None:
-            raise RuntimeError("Depth estimator not loaded")
-
-        # Preprocess
-        inputs = self._depth_processor(images=image, return_tensors="pt")
-        inputs = {k: v.to(self.device) for k, v in inputs.items()}
-
-        # Inference
-        with torch.no_grad():
-            outputs = self._depth_estimator(**inputs)
-            predicted_depth = outputs.predicted_depth
-
-        # Interpolate to original size
-        prediction = torch.nn.functional.interpolate(
-            predicted_depth.unsqueeze(1),
-            size=image.size[::-1],  # (H, W)
-            mode="bicubic",
-            align_corners=False
-        )
-
-        # Normalize to 0-255
-        depth_array = prediction.squeeze().cpu().numpy()
-        depth_min = depth_array.min()
-        depth_max = depth_array.max()
-
-        if depth_max - depth_min > 0:
-            depth_normalized = ((depth_array - depth_min) / (depth_max - depth_min) * 255)
-        else:
-            depth_normalized = np.zeros_like(depth_array)
-
-        depth_normalized = depth_normalized.astype(np.uint8)
-
-        # Convert to 3-channel for ControlNet
-        depth_3ch = cv2.cvtColor(depth_normalized, cv2.COLOR_GRAY2RGB)
-
-        logger.debug(f"Generated depth map, range: {depth_min:.2f} - {depth_max:.2f}")
-
-        return Image.fromarray(depth_3ch)
-
-    def prepare_mask(
-        self,
-        mask: Image.Image,
-        target_size: Tuple[int, int],
-        feather_radius: Optional[int] = None
-    ) -> Tuple[Image.Image, Dict[str, Any]]:
-        """
-        Prepare and validate mask for inpainting.
-
-        Parameters
-        ----------
-        mask : PIL.Image
-            Input mask (white = inpaint area)
-        target_size : tuple
-            Target (width, height) to match input image
-        feather_radius : int, optional
-            Feathering radius in pixels. Uses config default if None.
-
-        Returns
-        -------
-        tuple
-            (processed_mask, validation_info)
-
-        Raises
-        ------
-        ValueError
-            If mask coverage is outside acceptable range
-        """
-        feather = feather_radius if feather_radius is not None else self.config.feather_radius
-
-        # Convert to grayscale
-        if mask.mode != 'L':
-            mask = mask.convert('L')
-
-        # Resize to match target
-        if mask.size != target_size:
-            mask = mask.resize(target_size, Image.LANCZOS)
-
-        # Convert to array for processing
-        mask_array = np.array(mask)
-
-        # Calculate coverage
-        total_pixels = mask_array.size
-        white_pixels = np.count_nonzero(mask_array > 127)
-        coverage = white_pixels / total_pixels
-
-        validation_info = {
-            "coverage": coverage,
-            "white_pixels": white_pixels,
-            "total_pixels": total_pixels,
-            "feather_radius": feather,
-            "valid": True,
-            "warning": ""
-        }
-
-        # Validate coverage
-        if coverage < self.config.min_mask_coverage:
-            validation_info["valid"] = False
-            validation_info["warning"] = (
-                f"Mask coverage too low ({coverage:.1%}). "
-                f"Please select a larger area to inpaint."
-            )
-            logger.warning(f"Mask coverage {coverage:.1%} below minimum {self.config.min_mask_coverage:.1%}")
-
-        elif coverage > self.config.max_mask_coverage:
-            validation_info["valid"] = False
-            validation_info["warning"] = (
-                f"Mask coverage too high ({coverage:.1%}). "
-                f"Consider using background generation instead."
-            )
-            logger.warning(f"Mask coverage {coverage:.1%} above maximum {self.config.max_mask_coverage:.1%}")
-
-        # Apply feathering
-        if feather > 0:
-            mask_array = cv2.GaussianBlur(
-                mask_array,
-                (feather * 2 + 1, feather * 2 + 1),
-                feather / 2
-            )
-            logger.debug(f"Applied {feather}px feathering to mask")
-
-        processed_mask = Image.fromarray(mask_array, mode='L')
-
-        return processed_mask, validation_info
-
-    def enhance_prompt_for_inpainting(
-        self,
-        prompt: str,
-        image: Image.Image,
-        mask: Image.Image
-    ) -> Tuple[str, str]:
-        """
-        Enhance prompt based on non-masked region analysis.
-
-        Analyzes the surrounding context to generate appropriate
-        lighting and color descriptors.
-
-        Parameters
-        ----------
-        prompt : str
-            User-provided prompt
-        image : PIL.Image
-            Original image
-        mask : PIL.Image
-            Inpainting mask
-
-        Returns
-        -------
-        tuple
-            (enhanced_prompt, negative_prompt)
-        """
-        logger.info("Enhancing prompt for inpainting context...")
-
-        # Convert to arrays
-        img_array = np.array(image.convert('RGB'))
-        mask_array = np.array(mask.convert('L'))
-
-        # Analyze non-masked regions
-        non_masked = mask_array < 127
-
-        if not np.any(non_masked):
-            # No context available
-            enhanced_prompt = f"{prompt}, high quality, detailed, photorealistic"
-            negative_prompt = self._get_inpainting_negative_prompt()
-            return enhanced_prompt, negative_prompt
-
-        # Extract context pixels
-        context_pixels = img_array[non_masked]
-
-        # Convert to Lab for analysis
-        context_lab = cv2.cvtColor(
-            context_pixels.reshape(-1, 1, 3),
-            cv2.COLOR_RGB2LAB
-        ).reshape(-1, 3)
-
-        # Use robust statistics (median) to avoid outlier influence
-        median_l = np.median(context_lab[:, 0])
-        median_a = np.median(context_lab[:, 1])
-        median_b = np.median(context_lab[:, 2])
-
-        # Analyze lighting conditions
-        lighting_descriptors = []
-
-        if median_l > 170:
-            lighting_descriptors.append("bright")
-        elif median_l > 130:
-            lighting_descriptors.append("well-lit")
-        elif median_l > 80:
-            lighting_descriptors.append("moderate lighting")
-        else:
-            lighting_descriptors.append("dim lighting")
-
-        # Analyze color temperature (b channel: blue(-) to yellow(+))
-        if median_b > 140:
-            lighting_descriptors.append("warm golden tones")
-        elif median_b > 120:
-            lighting_descriptors.append("warm afternoon light")
-        elif median_b < 110:
-            lighting_descriptors.append("cool neutral tones")
-
-        # Calculate saturation from context
-        hsv = cv2.cvtColor(context_pixels.reshape(-1, 1, 3), cv2.COLOR_RGB2HSV)
-        median_saturation = np.median(hsv[:, :, 1])
-
-        if median_saturation > 150:
-            lighting_descriptors.append("vibrant colors")
-        elif median_saturation < 80:
-            lighting_descriptors.append("subtle muted colors")
-
-        # Build enhanced prompt
-        lighting_desc = ", ".join(lighting_descriptors) if lighting_descriptors else ""
-        quality_suffix = "high quality, detailed, photorealistic, seamless integration"
-
-        if lighting_desc:
-            enhanced_prompt = f"{prompt}, {lighting_desc}, {quality_suffix}"
-        else:
-            enhanced_prompt = f"{prompt}, {quality_suffix}"
-
-        negative_prompt = self._get_inpainting_negative_prompt()
-
-        logger.info(f"Enhanced prompt with context: {lighting_desc}")
-
-        return enhanced_prompt, negative_prompt
-
-    def _get_inpainting_negative_prompt(self) -> str:
-        """Get standard negative prompt for inpainting."""
-        return (
-            "inconsistent lighting, wrong perspective, mismatched colors, "
-            "visible seams, blending artifacts, color bleeding, "
-            "blurry, low quality, distorted, deformed, "
-            "harsh edges, unnatural transition"
-        )
+        logger.info("Pipeline unloaded")
 
     def execute_inpainting(
         self,
         image: Image.Image,
         mask: Image.Image,
         prompt: str,
-        preview_only: bool = False,
-        seed: Optional[int] = None,
         progress_callback: Optional[Callable[[str, int], None]] = None,
         **kwargs
     ) -> InpaintingResult:
         """
-        Execute the inpainting operation.
-
-        Implements two-stage generation: fast preview followed by
-        full quality generation if requested.
+        Execute inpainting operation.
 
         Parameters
         ----------
         image : PIL.Image
-            Original image to inpaint
+            Original image
         mask : PIL.Image
             Inpainting mask (white = area to regenerate)
         prompt : str
-            Text description of desired content
-        preview_only : bool
-            If True, only generate preview (faster)
-        seed : int, optional
-            Random seed for reproducibility
+            Text description
         progress_callback : callable, optional
-            Progress update function(message, percentage)
+            Progress update function
         **kwargs
-            Additional parameters:
-            - controlnet_conditioning_scale: float
-            - feather_radius: int
-            - num_inference_steps: int
-            - guidance_scale: float
+            Additional parameters from template
 
         Returns
         -------
         InpaintingResult
-            Result container with generated images and metadata
+            Result with generated image
         """
         start_time = time.time()
 
         if not self.is_initialized:
             return InpaintingResult(
                 success=False,
-                error_message="Inpainting pipeline not initialized. Call load_inpainting_pipeline() first."
+                error_message="Pipeline not initialized. Call load_pipeline() first."
             )
 
-        logger.info(f"Starting inpainting: prompt='{prompt[:50]}...', preview_only={preview_only}")
+        logger.info(f"Inpainting: mode={self._current_mode}, prompt='{prompt[:50]}...'")
 
         try:
-            # Update config with kwargs
-            conditioning_scale = kwargs.get(
-                'controlnet_conditioning_scale',
-                self.config.controlnet_conditioning_scale
-            )
-            feather_radius = kwargs.get('feather_radius', self.config.feather_radius)
-            strength = kwargs.get('strength', self.config.strength)
-            preserve_structure = kwargs.get('preserve_structure_in_mask', False)
-
             if progress_callback:
-                progress_callback("Preparing images...", 5)
+                progress_callback("Preparing images...", 10)
 
             # Prepare image
             if image.mode != 'RGB':
                 image = image.convert('RGB')
 
-            # Ensure dimensions are multiple of 8
+            # Store original size for later restoration
+            original_size = image.size  # (width, height)
+
+            # Ensure dimensions are multiple of 8 for model compatibility
             width, height = image.size
             new_width = (width // 8) * 8
             new_height = (height // 8) * 8
-
             if new_width != width or new_height != height:
                 image = image.resize((new_width, new_height), Image.LANCZOS)
 
-            # Check and potentially reduce resolution for memory
+            # Limit resolution for memory efficiency
             max_res = self.config.max_resolution
             if max(new_width, new_height) > max_res:
                 scale = max_res / max(new_width, new_height)
                 new_width = int(new_width * scale) // 8 * 8
                 new_height = int(new_height * scale) // 8 * 8
                 image = image.resize((new_width, new_height), Image.LANCZOS)
-                logger.info(f"Reduced resolution to {new_width}x{new_height} for memory")
 
-            # Prepare mask
-            if progress_callback:
-                progress_callback("Processing mask...", 10)
-
-            processed_mask, mask_info = self.prepare_mask(
+            # Prepare mask with dilation
+            mask_dilation = kwargs.get('mask_dilation', 0)
+            processed_mask = self._prepare_mask(
                 mask,
                 (new_width, new_height),
-                feather_radius
-            )
-
-            if not mask_info["valid"]:
-                return InpaintingResult(
-                    success=False,
-                    error_message=mask_info["warning"]
-                )
-
-            # Generate control image
-            if progress_callback:
-                progress_callback("Generating control image...", 20)
-
-            control_image = self.prepare_control_image(
-                image,
-                self._current_conditioning_type,
-                mask=processed_mask,
-                preserve_structure=preserve_structure  # True for color change, False for replacement/removal
+                dilation=mask_dilation,
+                feather_radius=kwargs.get('feather_radius', self.config.feather_radius)
             )
 
-            # Conditional prompt enhancement based on template
-            # Check if we should enhance the prompt or use it directly
-            should_enhance = kwargs.get('enhance_prompt', False)  # Default: no enhancement
+            # Get generation parameters
+            strength = kwargs.get('strength', self.config.strength)
+            guidance_scale = kwargs.get('guidance_scale', self.config.guidance_scale)
+            num_steps = kwargs.get('num_inference_steps', self.config.num_inference_steps)
+            negative_prompt = kwargs.get('negative_prompt', "")
 
-            if should_enhance:
-                if progress_callback:
-                    progress_callback("Enhancing prompt...", 25)
-                enhanced_prompt, negative_prompt = self.enhance_prompt_for_inpainting(
-                    prompt, image, processed_mask
-                )
-                logger.info(f"Prompt enhanced with OpenCLIP context")
-            else:
-                # Use prompt directly without enhancement
-                enhanced_prompt = prompt
-                negative_prompt = self._get_inpainting_negative_prompt()
-                logger.info("Prompt enhancement disabled for this template")
+            # Optimize for HuggingFace Spaces
+            is_spaces = os.getenv('SPACE_ID') is not None
+            if is_spaces:
+                num_steps = min(num_steps, 15)
 
-            # Setup generator for reproducibility
-            if seed is None:
+            # Setup generator with seed
+            # If seed is -1 or None, use random seed based on current time
+            input_seed = kwargs.get('seed', -1)
+            if input_seed is None or input_seed < 0:
                 seed = int(time.time() * 1000) % (2**32)
-            self._last_seed = seed
+            else:
+                seed = int(input_seed)
             generator = torch.Generator(device=self.device).manual_seed(seed)
+            logger.info(f"Using seed: {seed}")
 
-            # Check if running on Hugging Face Spaces
-            is_spaces = os.getenv('SPACE_ID') is not None
-
-            # Stage 1: Preview generation
-            # On Spaces, skip preview to save time (300s hard limit)
-            preview_result = None
-
-            if preview_only or not is_spaces:
+            # Generate based on mode
+            if self._current_mode == "pure":
+                # Pure inpainting - no ControlNet
                 if progress_callback:
-                    progress_callback("Generating preview...", 30)
-
-                # Optimize preview steps for Hugging Face Spaces
-                preview_steps = self.config.preview_steps
-                if is_spaces:
-                    # On Spaces, use minimal preview steps
-                    preview_steps = min(preview_steps, 8)
-                    logger.debug(f"Spaces environment - using {preview_steps} preview steps")
+                    progress_callback("Generating (Pure Inpainting)...", 40)
 
-                preview_result = self._generate_inpaint(
+                result_image = self._generate_pure_inpaint(
                     image=image,
                     mask=processed_mask,
-                    control_image=control_image,
-                    prompt=enhanced_prompt,
+                    prompt=prompt,
                     negative_prompt=negative_prompt,
-                    num_inference_steps=preview_steps,
-                    guidance_scale=self.config.preview_guidance_scale,
-                    controlnet_conditioning_scale=conditioning_scale,
+                    num_steps=num_steps,
+                    guidance_scale=guidance_scale,
                     strength=strength,
                     generator=generator
                 )
+                control_image = None
+
             else:
-                logger.debug("Spaces environment - skipping preview to fit 300s limit")
+                # ControlNet inpainting
+                if progress_callback:
+                    progress_callback("Generating control image...", 30)
 
-            if preview_only:
-                generation_time = time.time() - start_time
+                # Prepare control image
+                preserve_structure = kwargs.get('preserve_structure_in_mask', False)
+                edge_guidance_mode = kwargs.get('edge_guidance_mode', 'boundary')
 
-                return InpaintingResult(
-                    success=True,
-                    preview_image=preview_result,
-                    control_image=control_image,
-                    generation_time=generation_time,
-                    metadata={
-                        "seed": seed,
-                        "prompt": enhanced_prompt,
-                        "conditioning_type": self._current_conditioning_type,
-                        "conditioning_scale": conditioning_scale,
-                        "preview_only": True
-                    }
+                control_image = self._control_processor.prepare_control_image(
+                    image=image,
+                    mode=self._current_conditioning_type,
+                    mask=processed_mask,
+                    preserve_structure=preserve_structure,
+                    edge_guidance_mode=edge_guidance_mode
                 )
 
-            # Stage 2: Full quality generation
-            if progress_callback:
-                progress_callback("Generating full quality...", 60)
-
-            # Use same seed for reproducibility
-            generator = torch.Generator(device=self.device).manual_seed(seed)
-
-            num_steps = kwargs.get('num_inference_steps', self.config.num_inference_steps)
-            guidance = kwargs.get('guidance_scale', self.config.guidance_scale)
-
-            # Optimize for Hugging Face Spaces ZeroGPU (stateless, 300s hard limit)
-            if is_spaces:
-                # ZeroGPU timing breakdown with model caching (actual measurements):
-                # - Model loading from cache: ~60s (cached models, CPU to GPU transfer)
-                # - Inference: ~28-29s/step (observed on shared H200)
-                # - Blending & overhead: ~35s
-                # - Platform limit: 300s hard limit (Pro tier)
-                #
-                # Strategy with unified 10-step approach:
-                # - Skip preview completely (done above)
-                # - Use 10 steps for balance of quality and speed
-                # - Time budget: 60s (load) + 285s (10 steps) + 35s (blend) = 380s
-                # - Note: Still may timeout, but parameter optimization is more important than step count
-                # - Quality comes from correct conditioning_scale, not high step count
-
-                spaces_max_steps = 10  # Optimized: 10 steps sufficient with proper parameters
-
-                if num_steps > spaces_max_steps:
-                    num_steps = spaces_max_steps
-                    logger.debug(f"Spaces deployment: using {num_steps} steps (optimized for parameter quality)")
-
-            full_result = self._generate_inpaint(
-                image=image,
-                mask=processed_mask,
-                control_image=control_image,
-                prompt=enhanced_prompt,
-                negative_prompt=negative_prompt,
-                num_inference_steps=num_steps,
-                guidance_scale=guidance,
-                controlnet_conditioning_scale=conditioning_scale,
-                strength=strength,
-                generator=generator
-            )
+                if progress_callback:
+                    progress_callback("Generating (ControlNet)...", 50)
 
-            if progress_callback:
-                progress_callback("Blending result...", 90)
+                conditioning_scale = kwargs.get(
+                    'controlnet_conditioning_scale',
+                    self.config.controlnet_conditioning_scale
+                )
 
-            # Blend result
-            blended = self.blend_result(image, full_result, processed_mask)
+                result_image = self._generate_controlnet_inpaint(
+                    image=image,
+                    mask=processed_mask,
+                    control_image=control_image,
+                    prompt=prompt,
+                    negative_prompt=negative_prompt,
+                    num_steps=num_steps,
+                    guidance_scale=guidance_scale,
+                    conditioning_scale=conditioning_scale,
+                    strength=strength,
+                    generator=generator
+                )
 
             generation_time = time.time() - start_time
 
+            # Restore original size if it was changed
+            if result_image.size != original_size:
+                result_image = result_image.resize(original_size, Image.LANCZOS)
+                logger.info(f"Restored result to original size: {original_size}")
+
             if progress_callback:
                 progress_callback("Complete!", 100)
 
             return InpaintingResult(
                 success=True,
-                result_image=full_result,
-                preview_image=preview_result,
+                result_image=result_image,
+                blended_image=result_image,  # Pipeline output is already blended
                 control_image=control_image,
-                blended_image=blended,
                 generation_time=generation_time,
                 metadata={
                     "seed": seed,
-                    "prompt": enhanced_prompt,
-                    "negative_prompt": negative_prompt,
-                    "conditioning_type": self._current_conditioning_type,
-                    "conditioning_scale": conditioning_scale,
+                    "prompt": prompt,
+                    "mode": self._current_mode,
+                    "num_steps": num_steps,
+                    "guidance_scale": guidance_scale,
                     "strength": strength,
-                    "preserve_structure": preserve_structure,
-                    "num_inference_steps": num_steps,
-                    "guidance_scale": guidance,
-                    "feather_radius": feather_radius,
-                    "mask_coverage": mask_info["coverage"],
-                    "preview_only": False
+                    "original_size": original_size,
                 }
             )
 
         except torch.cuda.OutOfMemoryError:
-            logger.error("CUDA out of memory during inpainting")
+            logger.error("CUDA out of memory")
             self._memory_cleanup(aggressive=True)
             return InpaintingResult(
                 success=False,
-                error_message="GPU memory exhausted. Try reducing image size or closing other applications."
+                error_message="GPU memory exhausted."
             )
-
         except Exception as e:
             logger.error(f"Inpainting failed: {e}")
-            logger.error(traceback.format_exc())
+            traceback.print_exc()
             return InpaintingResult(
                 success=False,
-                error_message=f"Inpainting failed: {str(e)}"
+                error_message=str(e)
             )
 
-    def _generate_inpaint(
+    def _prepare_mask(
         self,
-        image: Image.Image,
         mask: Image.Image,
-        control_image: Image.Image,
-        prompt: str,
-        negative_prompt: str,
-        num_inference_steps: int,
-        guidance_scale: float,
-        controlnet_conditioning_scale: float,
-        strength: float,
-        generator: torch.Generator
-    ) -> Image.Image:
-        """
-        Internal method to run the inpainting pipeline.
-
-        Supports both ControlNet and non-ControlNet pipelines.
-
-        Parameters
-        ----------
-        image : PIL.Image
-            Original image
-        mask : PIL.Image
-            Processed mask
-        control_image : PIL.Image
-            ControlNet conditioning image (ignored if ControlNet not available)
-        prompt : str
-            Enhanced prompt
-        negative_prompt : str
-            Negative prompt
-        num_inference_steps : int
-            Number of denoising steps
-        guidance_scale : float
-            Classifier-free guidance scale
-        controlnet_conditioning_scale : float
-            ControlNet influence strength (ignored if ControlNet not available)
-        strength : float
-            Inpainting strength (0.0-1.0). 1.0 = fully repaint masked area.
-        generator : torch.Generator
-            Random generator for reproducibility
-
-        Returns
-        -------
-        PIL.Image
-            Generated image
-        """
-        with torch.inference_mode():
-            if self._use_controlnet:
-                # Full ControlNet inpainting pipeline
-                result = self._inpaint_pipeline(
-                    prompt=prompt,
-                    negative_prompt=negative_prompt,
-                    image=image,
-                    mask_image=mask,
-                    control_image=control_image,
-                    num_inference_steps=num_inference_steps,
-                    guidance_scale=guidance_scale,
-                    controlnet_conditioning_scale=controlnet_conditioning_scale,
-                    strength=strength,
-                    generator=generator
-                )
-            else:
-                # Fallback: Standard SDXL inpainting without ControlNet
-                result = self._inpaint_pipeline(
-                    prompt=prompt,
-                    negative_prompt=negative_prompt,
-                    image=image,
-                    mask_image=mask,
-                    num_inference_steps=num_inference_steps,
-                    guidance_scale=guidance_scale,
-                    strength=strength,
-                    generator=generator
-                )
-
-        return result.images[0]
-
-    def blend_result(
-        self,
-        original: Image.Image,
-        generated: Image.Image,
-        mask: Image.Image
+        target_size: Tuple[int, int],
+        dilation: int = 0,
+        feather_radius: int = 3
     ) -> Image.Image:
-        """
-        Blend generated content with original image.
-
-        Uses linear color space blending for accurate results.
+        """Prepare mask with optional dilation and feathering."""
+        # Convert and resize
+        if mask.mode != 'L':
+            mask = mask.convert('L')
+        if mask.size != target_size:
+            mask = mask.resize(target_size, Image.LANCZOS)
 
-        Parameters
-        ----------
-        original : PIL.Image
-            Original image
-        generated : PIL.Image
-            Generated inpainted image
-        mask : PIL.Image
-            Blending mask (white = use generated)
+        mask_array = np.array(mask)
 
-        Returns
-        -------
-        PIL.Image
-            Blended result
-        """
-        logger.info("Blending inpainting result...")
-
-        # Ensure same size
-        if generated.size != original.size:
-            generated = generated.resize(original.size, Image.LANCZOS)
-        if mask.size != original.size:
-            mask = mask.resize(original.size, Image.LANCZOS)
-
-        # Convert to arrays
-        orig_array = np.array(original.convert('RGB')).astype(np.float32)
-        gen_array = np.array(generated.convert('RGB')).astype(np.float32)
-        mask_array = np.array(mask.convert('L')).astype(np.float32) / 255.0
-
-        # sRGB to linear conversion
-        def srgb_to_linear(img):
-            img_norm = img / 255.0
-            return np.where(
-                img_norm <= 0.04045,
-                img_norm / 12.92,
-                np.power((img_norm + 0.055) / 1.055, 2.4)
+        # Apply dilation to expand mask
+        if dilation > 0:
+            kernel = cv2.getStructuringElement(
+                cv2.MORPH_ELLIPSE,
+                (dilation * 2 + 1, dilation * 2 + 1)
             )
+            mask_array = cv2.dilate(mask_array, kernel, iterations=1)
+            logger.debug(f"Applied mask dilation: {dilation}px")
 
-        def linear_to_srgb(img):
-            img_clipped = np.clip(img, 0, 1)
-            return np.where(
-                img_clipped <= 0.0031308,
-                12.92 * img_clipped,
-                1.055 * np.power(img_clipped, 1/2.4) - 0.055
+        # Apply feathering
+        if feather_radius > 0:
+            mask_array = cv2.GaussianBlur(
+                mask_array,
+                (feather_radius * 2 + 1, feather_radius * 2 + 1),
+                feather_radius / 2
             )
 
-        # Convert to linear space
-        orig_linear = srgb_to_linear(orig_array)
-        gen_linear = srgb_to_linear(gen_array)
-
-        # Alpha blending in linear space
-        alpha = mask_array[:, :, np.newaxis]
-        result_linear = gen_linear * alpha + orig_linear * (1 - alpha)
-
-        # Convert back to sRGB
-        result_srgb = linear_to_srgb(result_linear)
-        result_array = (result_srgb * 255).astype(np.uint8)
+        return Image.fromarray(mask_array, mode='L')
 
-        logger.debug("Blending completed in linear color space")
-
-        return Image.fromarray(result_array)
-
-    def execute_with_auto_optimization(
+    def _generate_pure_inpaint(
         self,
         image: Image.Image,
         mask: Image.Image,
         prompt: str,
-        quality_checker: Any,
-        progress_callback: Optional[Callable[[str, int], None]] = None,
-        **kwargs
-    ) -> InpaintingResult:
-        """
-        Execute inpainting with automatic quality-based optimization.
-
-        Retries with adjusted parameters if quality score is below threshold.
-
-        Parameters
-        ----------
-        image : PIL.Image
-            Original image
-        mask : PIL.Image
-            Inpainting mask
-        prompt : str
-            Text prompt
-        quality_checker : QualityChecker
-            Quality assessment instance
-        progress_callback : callable, optional
-            Progress update function
-        **kwargs
-            Additional inpainting parameters
-
-        Returns
-        -------
-        InpaintingResult
-            Best result achieved (may include retry information)
-        """
-        if not self.config.enable_auto_optimization:
-            return self.execute_inpainting(
-                image, mask, prompt,
-                progress_callback=progress_callback,
-                **kwargs
+        negative_prompt: str,
+        num_steps: int,
+        guidance_scale: float,
+        strength: float,
+        generator: torch.Generator
+    ) -> Image.Image:
+        """Generate using pure SDXL Inpainting pipeline."""
+        with torch.inference_mode():
+            result = self._pipeline(
+                prompt=prompt,
+                negative_prompt=negative_prompt,
+                image=image,
+                mask_image=mask,
+                num_inference_steps=num_steps,
+                guidance_scale=guidance_scale,
+                strength=strength,
+                generator=generator
             )
+        return result.images[0]
 
-        best_result = None
-        best_score = 0.0
-        retry_count = 0
-        prev_score = 0.0
-
-        # Mutable parameters for optimization
-        current_feather = kwargs.get('feather_radius', self.config.feather_radius)
-        current_scale = kwargs.get(
-            'controlnet_conditioning_scale',
-            self.config.controlnet_conditioning_scale
-        )
-        current_guidance = kwargs.get('guidance_scale', self.config.guidance_scale)
-        current_prompt = prompt
-
-        while retry_count <= self.config.max_optimization_retries:
-            if progress_callback and retry_count > 0:
-                progress_callback(f"Optimizing (attempt {retry_count + 1})...", 5)
-
-            # Execute inpainting
-            result = self.execute_inpainting(
-                image, mask, current_prompt,
-                preview_only=False,
-                feather_radius=current_feather,
-                controlnet_conditioning_scale=current_scale,
-                guidance_scale=current_guidance,
-                progress_callback=progress_callback if retry_count == 0 else None,
-                **{k: v for k, v in kwargs.items()
-                   if k not in ['feather_radius', 'controlnet_conditioning_scale',
-                               'guidance_scale']}
+    def _generate_controlnet_inpaint(
+        self,
+        image: Image.Image,
+        mask: Image.Image,
+        control_image: Image.Image,
+        prompt: str,
+        negative_prompt: str,
+        num_steps: int,
+        guidance_scale: float,
+        conditioning_scale: float,
+        strength: float,
+        generator: torch.Generator
+    ) -> Image.Image:
+        """Generate using ControlNet Inpainting pipeline."""
+        with torch.inference_mode():
+            result = self._pipeline(
+                prompt=prompt,
+                negative_prompt=negative_prompt,
+                image=image,
+                mask_image=mask,
+                control_image=control_image,
+                num_inference_steps=num_steps,
+                guidance_scale=guidance_scale,
+                controlnet_conditioning_scale=conditioning_scale,
+                strength=strength,
+                generator=generator
             )
-
-            if not result.success:
-                return result
-
-            # Evaluate quality
-            if result.blended_image is not None:
-                quality_results = quality_checker.run_all_checks(
-                    foreground=image,
-                    background=result.result_image,
-                    mask=mask,
-                    combined=result.blended_image
-                )
-                quality_score = quality_results.get("overall_score", 0)
-            else:
-                quality_score = 50.0  # Default if no blended image
-
-            result.quality_score = quality_score
-            result.quality_details = quality_results if result.blended_image else {}
-            result.retries = retry_count
-
-            logger.info(f"Quality score: {quality_score:.1f} (attempt {retry_count + 1})")
-
-            # Track best result
-            if quality_score > best_score:
-                best_score = quality_score
-                best_result = result
-
-            # Check if quality is acceptable
-            if quality_score >= self.config.min_quality_score:
-                logger.info(f"Quality threshold met: {quality_score:.1f}")
-                return best_result
-
-            # Check for minimal improvement (early termination)
-            if retry_count > 0 and abs(quality_score - prev_score) < 5.0:
-                logger.info("Minimal improvement, stopping optimization")
-                return best_result
-
-            prev_score = quality_score
-            retry_count += 1
-
-            if retry_count > self.config.max_optimization_retries:
-                break
-
-            # Adjust parameters based on quality issues
-            checks = quality_results.get("checks", {})
-
-            edge_score = checks.get("edge_continuity", {}).get("score", 100)
-            harmony_score = checks.get("color_harmony", {}).get("score", 100)
-
-            if edge_score < 60:
-                # Edge issues: increase feathering, decrease control strength
-                current_feather = min(20, current_feather + 3)
-                current_scale = max(0.5, current_scale - 0.1)
-                logger.debug(f"Adjusting for edges: feather={current_feather}, scale={current_scale}")
-
-            if harmony_score < 60:
-                # Color harmony issues: emphasize consistency in prompt
-                if "color consistent" not in current_prompt.lower():
-                    current_prompt = f"{current_prompt}, color consistent with surroundings, matching lighting"
-                current_guidance = min(12.0, current_guidance + 1.0)
-                logger.debug(f"Adjusting for harmony: guidance={current_guidance}")
-
-            if edge_score < 60 and harmony_score < 60:
-                # Both issues: stronger guidance
-                current_guidance = min(12.0, current_guidance + 1.5)
-
-        logger.info(f"Optimization complete. Best score: {best_score:.1f}")
-        return best_result
+        return result.images[0]
 
     def get_status(self) -> Dict[str, Any]:
-        """
-        Get current module status.
-
-        Returns
-        -------
-        dict
-            Status information including initialization state and memory usage
-        """
-        status = {
+        """Get current module status."""
+        return {
             "initialized": self.is_initialized,
             "device": self.device,
+            "mode": self._current_mode,
             "conditioning_type": self._current_conditioning_type,
-            "last_seed": self._last_seed,
-            "config": {
-                "controlnet_conditioning_scale": self.config.controlnet_conditioning_scale,
-                "feather_radius": self.config.feather_radius,
-                "num_inference_steps": self.config.num_inference_steps,
-                "guidance_scale": self.config.guidance_scale
-            }
+            "model_key": self._current_model_key,
         }
-
-        status["memory"] = self._check_memory_status()
-
-        return status

inpainting_templates.py

@@ -1,6 +1,6 @@
 import logging
 from dataclasses import dataclass, field
-from typing import Dict, List, Optional
+from typing import Any, Dict, List, Optional
 
 logger = logging.getLogger(__name__)
 
@@ -19,30 +19,31 @@ class InpaintingTemplate:
     prompt_template: str
     negative_prompt: str
 
-    # Recommended parameters
-    controlnet_conditioning_scale: float = 0.7
-    feather_radius: int = 8
-    guidance_scale: float = 7.5
-    num_inference_steps: int = 25
+    # Pipeline mode selection
+    use_controlnet: bool = True  # False = use pure SDXL Inpainting model (more stable)
+    mask_dilation: int = 0       # Pixels to expand mask for better edge blending
 
-    # Inpainting strength (0.0-1.0)
-    # 1.0 = fully repaint masked area, 0.0 = keep original
-    strength: float = 1.0
-
-    # Conditioning type preference
+    # ControlNet parameters (only used when use_controlnet=True)
+    controlnet_conditioning_scale: float = 0.7
     preferred_conditioning: str = "canny"  # "canny" or "depth"
-
-    # Structure preservation in masked area
-    # True = keep edges in mask (for color change), False = clear edges (for replacement/removal)
     preserve_structure_in_mask: bool = False
+    edge_guidance_mode: str = "boundary"
 
-    # Prompt enhancement control
-    enhance_prompt: bool = True  # Whether to use OpenCLIP prompt enhancement
+    # Generation parameters
+    guidance_scale: float = 7.5
+    num_inference_steps: int = 25
+    strength: float = 0.99  # Use 0.99 instead of 1.0 to avoid noise issues
+
+    # Mask parameters
+    feather_radius: int = 3  # Minimal feathering, let pipeline handle blending
 
-    # Difficulty level for UI display
-    difficulty: str = "medium"  # "easy", "medium", "advanced"
+    # Prompt enhancement
+    enhance_prompt: bool = True
 
-    # Tips for users
+    # UI metadata
+    difficulty: str = "medium"
+    recommended_models: List[str] = field(default_factory=lambda: ["sdxl_base"])
+    example_prompts: List[str] = field(default_factory=list)
     usage_tips: List[str] = field(default_factory=list)
 
 
@@ -50,417 +51,338 @@ class InpaintingTemplateManager:
     """
     Manages inpainting templates for various use cases.
 
-    Provides categorized presets optimized for different inpainting scenarios
-    including object replacement, removal, style transfer, and enhancement.
-
-    Attributes:
-        TEMPLATES: Dictionary of all available templates
-        CATEGORIES: List of category names in display order
+    Templates are categorized into two pipeline modes:
+    - Pure Inpainting (use_controlnet=False): For replacement/removal tasks
+    - ControlNet Inpainting (use_controlnet=True): For structure-preserving tasks
 
     Example:
         >>> manager = InpaintingTemplateManager()
         >>> template = manager.get_template("object_replacement")
-        >>> print(template.prompt_template)
+        >>> if not template.use_controlnet:
+        ...     # Use pure SDXL Inpainting pipeline
+        ...     pass
     """
 
     TEMPLATES: Dict[str, InpaintingTemplate] = {
-        # ========================================
-        # 4 CORE TEMPLATES - Optimized for Speed & Quality
-        # ========================================
-
-        # 1. CHANGE COLOR - Pure color transformation
-        "change_color": InpaintingTemplate(
-            key="change_color",
-            name="Change Color",
-            category="Color",
-            icon="🎨",
-            description="Change color ONLY - fills the masked area with a solid, flat color",
-            prompt_template="{content} color, solid flat {content}, uniform color, no patterns, smooth surface",
+        # 1. OBJECT REPLACEMENT - Replace one object with another
+        "object_replacement": InpaintingTemplate(
+            key="object_replacement",
+            name="Object Replacement",
+            category="Replacement",
+            icon="🔄",
+            description="Replace objects naturally - uses dedicated inpainting model for best results",
+            prompt_template="{content}, photorealistic, natural lighting, seamlessly integrated, high quality, detailed",
             negative_prompt=(
-                "original color, keeping same color, unchanged color, "
-                "black, dark, keeping black, maintaining black color, "
-                "black clothing, dark colors, dark fabric, black fabric, "
-                "patterns, floral, stripes, plaid, checkered, decorative patterns, "
-                "diamond pattern, grid pattern, geometric patterns, "
-                "texture, textured, wrinkles, folds, creases, "
-                "gradients, shading variations, color variations, "
-                "complex patterns, printed patterns, embroidery"
+                "blurry, low quality, distorted, deformed, "
+                "visible seams, harsh edges, unnatural, "
+                "cartoon, anime, illustration, drawing"
             ),
-            controlnet_conditioning_scale=0.3,    # Low-medium: allow color freedom in masked area
-            feather_radius=4,                     # Low: clean color boundaries
-            guidance_scale=15.0,                  # Very high: strongly follow color prompt
-            num_inference_steps=10,               # Optimized for speed
-            strength=1.0,                         # Full repaint for color change
-            preferred_conditioning="canny",       # Edge-based
-            preserve_structure_in_mask=False,     # KEY: clear edges in mask for pure color fill
-            enhance_prompt=False,                 # Disabled: use color prompt directly
+            # Pipeline mode
+            use_controlnet=False,  # Pure inpainting for stable results
+            mask_dilation=5,       # Expand mask for seamless blending
+
+            # Generation parameters
+            guidance_scale=8.0,
+            num_inference_steps=25,
+            strength=0.99,
+
+            # Mask parameters
+            feather_radius=3,
+
+            # Not used for Pure Inpainting but kept for compatibility
+            controlnet_conditioning_scale=0.0,
+            preferred_conditioning="canny",  # Placeholder, not used in Pure Inpainting mode
+            preserve_structure_in_mask=False,
+            edge_guidance_mode="none",
+
+            enhance_prompt=True,
             difficulty="easy",
+            recommended_models=["realvis_xl", "juggernaut_xl"],
+            example_prompts=[
+                "elegant ceramic vase with fresh roses",
+                "modern minimalist desk lamp, chrome finish",
+                "vintage leather-bound book with gold lettering"
+            ],
             usage_tips=[
-                "🎯 Purpose: Fill the masked area with a solid, uniform color.",
+                "🎯 Purpose: Replace an object with something completely different.",
                 "",
-                "📝 Example Prompts:",
-                "  • 'vibrant red' - bold, saturated red",
-                "  • 'soft pastel pink' - gentle, light pink",
-                "  • 'deep navy blue' - rich, dark blue",
-                "  • 'bright yellow' - eye-catching yellow",
-                "  • 'pure white' - clean, solid white",
+                "💡 Example Prompts:",
+                "  • elegant ceramic vase with fresh roses",
+                "  • modern minimalist desk lamp, chrome finish",
+                "  • vintage leather-bound book with gold lettering",
                 "",
                 "💡 Tips:",
-                "  • Describe ONLY the color, not the object",
-                "  • Paint the entire area you want to recolor",
-                "  • Use modifiers: 'bright', 'dark', 'pastel', 'vivid'"
+                "  • Draw mask slightly larger than the object",
+                "  • Describe the NEW object in detail",
+                "  • Include material, color, style for better results"
             ]
         ),
 
-        # 2. CLOTHING CHANGE - Style and garment transformation
-        "clothing_change": InpaintingTemplate(
-            key="clothing_change",
-            name="Clothing Change",
-            category="Replacement",
-            icon="👕",
-            description="Change clothing style, material, or design - can include color change",
-            prompt_template="{content}, photorealistic, realistic fabric texture, natural fit, high quality",
+        # 2. OBJECT REMOVAL - Remove and fill with background (NO PROMPT NEEDED)
+        "removal": InpaintingTemplate(
+            key="removal",
+            name="Remove Object",
+            category="Removal",
+            icon="🗑️",
+            description="Remove unwanted objects - just draw mask, no prompt needed",
+            prompt_template="seamless background, natural texture continuation, photorealistic, high quality",
             negative_prompt=(
-                "wrong body proportions, floating fabric, unrealistic wrinkles, "
-                "mismatched lighting, visible edges, original clothing style, "
-                "keeping same color, original color, faded colors, unchanged appearance, partial change, "
-                "black clothing, dark original color, distorted body, naked, nudity, "
-                "cartoon, anime, illustration, drawing, painted"
+                "object, item, thing, foreground element, new object, "
+                "visible patch, inconsistent texture, "
+                "blurry, low quality, artificial"
             ),
-            controlnet_conditioning_scale=0.30,   # Medium: preserves body structure, allows clothing change
-            feather_radius=14,                    # Medium: natural blending with body
-            guidance_scale=11.5,                  # Medium-high: accurate clothing generation
-            num_inference_steps=10,               # Optimized for speed
-            strength=1.0,                         # Full repaint: completely replace clothing
-            preferred_conditioning="depth",       # Depth: preserves fabric folds and body structure
-            enhance_prompt=True,                  # Enabled: enriches clothing details
+            # Pipeline mode
+            use_controlnet=False,  # Pure inpainting for clean removal
+            mask_dilation=8,       # Larger expansion to cover shadows/reflections
+
+            # Generation parameters
+            guidance_scale=7.0,    # Lower guidance for natural fill
+            num_inference_steps=20,
+            strength=0.99,
+
+            # Mask parameters
+            feather_radius=5,      # More feathering for seamless blend
+
+            # Not used for Pure Inpainting but kept for compatibility
+            controlnet_conditioning_scale=0.0,
+            preferred_conditioning="canny",
+            preserve_structure_in_mask=False,
+            edge_guidance_mode="none",
+
+            enhance_prompt=False,  # Do NOT enhance - keep it simple
             difficulty="easy",
+            recommended_models=["realvis_xl", "juggernaut_xl"],
+            example_prompts=[],    # No prompts needed for removal
             usage_tips=[
-                "🎯 Purpose: Replace clothing with a different style, material, or design.",
+                "🎯 Purpose: Remove unwanted objects from image.",
                 "",
-                "📝 Example Prompts:",
-                "  • 'tailored charcoal suit with silk tie and white shirt' - formal business",
-                "  • 'navy blazer with gold buttons over light blue oxford shirt' - smart casual",
-                "  • 'black tuxedo with bow tie and white dress shirt' - elegant formal",
-                "  • 'white polo shirt with collar' - casual business",
-                "  • 'cozy cream knit sweater' - warm casual style",
-                "  • 'vintage denim jacket' - retro fashion",
+                "📝 No prompt needed! Just:",
+                "  1. Draw white mask over the object",
+                "  2. Include shadows in your mask",
+                "  3. Click Generate",
                 "",
                 "💡 Tips:",
-                "  • Include clothing type + color + details for best results",
-                "  • For suits: mention 'tailored', 'fitted', specific fabric like 'wool' or 'silk'",
-                "  • Body structure is preserved automatically"
+                "  • Make mask larger than the object",
+                "  • If artifacts remain, draw a bigger mask and retry"
             ]
         ),
 
-        # 3. OBJECT REPLACEMENT - Replace one object with another
-        "object_replacement": InpaintingTemplate(
-            key="object_replacement",
-            name="Object Replacement",
+        # CONTROLNET TEMPLATES (Structure Preserving)
+        # 3. CLOTHING CHANGE - Change clothes while keeping body
+        "clothing_change": InpaintingTemplate(
+            key="clothing_change",
+            name="Clothing Change",
             category="Replacement",
-            icon="🔄",
-            description="Replace objects (one type at a time) - all masked areas become the SAME object",
-            prompt_template="{content}, photorealistic, natural lighting, seamlessly integrated into scene, high quality",
+            icon="👕",
+            description="Change clothing style while preserving body structure",
+            prompt_template="{content}, photorealistic, realistic fabric, natural fit, high quality",
             negative_prompt=(
-                "inconsistent lighting, wrong perspective, mismatched colors, "
-                "visible seams, floating objects, unrealistic placement, original object, "
-                "poorly integrated, disconnected from scene, keeping original, remnants of original, "
-                "multiple different objects, mixed objects, various items, "
-                "cartoon, anime, illustration, drawing, painted"
+                "wrong proportions, distorted body, floating fabric, "
+                "mismatched lighting, naked, nudity, "
+                "cartoon, anime, illustration"
             ),
-            controlnet_conditioning_scale=0.25,   # Low-medium: allows complete object replacement
-            feather_radius=10,                    # Medium: natural scene integration
-            guidance_scale=13.0,                  # Medium-high: accurate object generation
-            num_inference_steps=10,               # Optimized for speed
-            strength=1.0,                         # Full repaint: completely replace object
-            preferred_conditioning="canny",       # Edge-based: preserves scene perspective
-            enhance_prompt=True,                  # Enabled: enriches object details
+            # Pipeline mode
+            use_controlnet=True,   # Need ControlNet to preserve body
+            mask_dilation=3,       # Small expansion for clothing edges
+
+            # ControlNet parameters
+            controlnet_conditioning_scale=0.4,
+            preferred_conditioning="depth",  # Depth preserves body structure
+            preserve_structure_in_mask=False,
+            edge_guidance_mode="soft",
+
+            # Generation parameters
+            guidance_scale=8.0,
+            num_inference_steps=25,
+            strength=1.0,  # Full repaint for clothing
+
+            # Mask parameters
+            feather_radius=5,
+
+            enhance_prompt=True,
             difficulty="medium",
+            recommended_models=["juggernaut_xl", "realvis_xl"],
+            example_prompts=[
+                "tailored charcoal suit with silk tie",
+                "navy blazer with gold buttons",
+                "elegant black evening dress",
+                "casual white t-shirt",
+                "cozy cream sweater",
+                "leather motorcycle jacket",
+                "formal white dress shirt",
+                "vintage denim jacket",
+                "red cocktail dress",
+                "professional grey blazer"
+            ],
             usage_tips=[
-                "🎯 Purpose: Replace an object with something completely different.",
+                "🎯 Purpose: Change clothing while keeping body shape.",
                 "",
-                "📝 Example Prompts:",
-                "  • 'elegant ceramic vase with fresh roses' - decorative item",
-                "  • 'modern silver laptop on wooden stand' - tech gadget",
-                "  • 'stack of leather-bound vintage books' - classic decoration",
-                "  • 'healthy green potted succulent' - natural element",
-                "  • 'antique brass table lamp with fabric shade' - lighting",
+                "🤖 Recommended Models:",
+                "  • JuggernautXL - Best for formal wear",
+                "  • RealVisXL - Great for casual clothing",
                 "",
                 "💡 Tips:",
-                "  • Replace ONE object type at a time",
-                "  • Describe what you want, not what you're removing",
-                "  • Include material and style for realistic results"
+                "  • Mask only the clothing area",
+                "  • Include fabric type: 'silk', 'cotton', 'wool'",
+                "  • Body proportions are preserved automatically"
             ]
         ),
 
-        # 4. REMOVAL - Remove objects and fill with background
-        "removal": InpaintingTemplate(
-            key="removal",
-            name="Remove Object",
-            category="Removal",
-            icon="🗑️",
-            description="Remove objects and naturally fill with background - describe the background material",
-            prompt_template="continue the background with {content}, photorealistic, seamless blending, natural texture continuation, high quality",
+        # 4. COLOR CHANGE - Change color only, keep structure
+        "change_color": InpaintingTemplate(
+            key="change_color",
+            name="Change Color",
+            category="Color",
+            icon="🎨",
+            description="Change color only - strictly preserves shape and texture",
+            prompt_template="{content} color, solid uniform {content}, flat color, smooth surface",
             negative_prompt=(
-                "new object appearing, adding items, inserting objects, "
-                "foreground elements, visible object, thing, item, "
-                "unnatural filling, visible patches, inconsistent texture, "
-                "mismatched pattern, color discontinuity, artificial blending, "
-                "cartoon, anime, illustration, drawing, painted"
+                "different shape, changed structure, new pattern, "
+                "texture change, deformed, distorted, "
+                "gradient, multiple colors, pattern"
             ),
-            controlnet_conditioning_scale=0.20,   # Low: allows creative background filling
-            feather_radius=12,                    # Medium: smooth background blending
-            guidance_scale=12.0,                  # Medium: balanced control and naturalness
-            num_inference_steps=10,               # Optimized for speed
-            strength=1.0,                         # Full repaint: completely remove and fill
-            preferred_conditioning="depth",       # Depth: preserves spatial perspective
-            enhance_prompt=False,                 # Disabled: avoid generating new objects
-            difficulty="medium",
+            # Pipeline mode
+            use_controlnet=True,   # Need ControlNet to preserve exact shape
+            mask_dilation=0,       # No expansion - precise color change
+
+            # ControlNet parameters
+            controlnet_conditioning_scale=0.85,  # High: strict structure preservation
+            preferred_conditioning="canny",       # Canny preserves edges exactly
+            preserve_structure_in_mask=True,      # Keep all edges
+            edge_guidance_mode="boundary",
+
+            # Generation parameters
+            guidance_scale=12.0,   # High: force the exact color
+            num_inference_steps=15,
+            strength=1.0,
+
+            # Mask parameters
+            feather_radius=2,      # Very small
+
+            enhance_prompt=False,  # Use color prompt directly
+            difficulty="easy",
+            recommended_models=["juggernaut_xl", "realvis_xl"],
+            example_prompts=[
+                "vibrant red",
+                "deep navy blue",
+                "bright yellow",
+                "emerald green",
+                "soft pink",
+                "pure white",
+                "charcoal grey",
+                "royal purple",
+                "coral orange",
+                "golden brown"
+            ],
             usage_tips=[
-                "🎯 Purpose: Remove unwanted objects and fill with background.",
-                "",
-                "📝 Example Prompts:",
-                "  • 'polished hardwood floor with natural grain' - indoor floors",
-                "  • 'smooth white painted wall' - wall backgrounds",
-                "  • 'lush green grass lawn' - outdoor areas",
-                "  • 'soft beige carpet texture' - carpeted floors",
-                "  • 'clear blue sky with soft clouds' - sky backgrounds",
+                "🎯 Purpose: Change color only, shape stays exactly the same.",
                 "",
                 "💡 Tips:",
-                "  • Describe the BACKGROUND texture, not the object",
-                "  • Leave empty to auto-match surrounding area",
-                "  • Works best with uniform backgrounds"
+                "  • Enter ONLY the color name",
+                "  • Use modifiers: 'bright', 'dark', 'pastel'",
+                "  • Shape and texture are preserved exactly"
             ]
         ),
     }
 
-
     # Category display order
-    CATEGORIES = ["Color", "Replacement", "Removal"]  # 4 core templates only
+    CATEGORIES = ["Color", "Replacement", "Removal"]
 
     def __init__(self):
         """Initialize the InpaintingTemplateManager."""
         logger.info(f"InpaintingTemplateManager initialized with {len(self.TEMPLATES)} templates")
 
     def get_all_templates(self) -> Dict[str, InpaintingTemplate]:
-        """
-        Get all available templates.
-
-        Returns
-        -------
-        dict
-            Dictionary of all templates keyed by template key
-        """
+        """Get all available templates."""
         return self.TEMPLATES
 
     def get_template(self, key: str) -> Optional[InpaintingTemplate]:
-        """
-        Get a specific template by key.
-
-        Parameters
-        ----------
-        key : str
-            Template identifier
-
-        Returns
-        -------
-        InpaintingTemplate or None
-            Template if found, None otherwise
-        """
+        """Get a specific template by key."""
         return self.TEMPLATES.get(key)
 
     def get_templates_by_category(self, category: str) -> List[InpaintingTemplate]:
-        """
-        Get all templates in a specific category.
-
-        Parameters
-        ----------
-        category : str
-            Category name
-
-        Returns
-        -------
-        list
-            List of templates in the category
-        """
+        """Get all templates in a specific category."""
         return [t for t in self.TEMPLATES.values() if t.category == category]
 
     def get_categories(self) -> List[str]:
-        """
-        Get list of all categories in display order.
-
-        Returns
-        -------
-        list
-            Category names
-        """
+        """Get list of all categories in display order."""
         return self.CATEGORIES
 
     def get_template_choices_sorted(self) -> List[str]:
-        """
-        Get template choices formatted for Gradio dropdown.
-
-        Returns list of display strings sorted by category then A-Z.
-        Format: "icon Name"
-
-        Returns
-        -------
-        list
-            Formatted display strings for dropdown
-        """
+        """Get template choices formatted for Gradio dropdown."""
         display_list = []
-
         for category in self.CATEGORIES:
             templates = self.get_templates_by_category(category)
             for template in sorted(templates, key=lambda t: t.name):
                 display_name = f"{template.icon} {template.name}"
                 display_list.append(display_name)
-
         return display_list
 
     def get_template_key_from_display(self, display_name: str) -> Optional[str]:
-        """
-        Get template key from display name.
-
-        Parameters
-        ----------
-        display_name : str
-            Display string like "🔄 Object Replacement"
-
-        Returns
-        -------
-        str or None
-            Template key if found
-        """
+        """Get template key from display name."""
         if not display_name:
             return None
-
         for key, template in self.TEMPLATES.items():
             if f"{template.icon} {template.name}" == display_name:
                 return key
         return None
 
-    def get_parameters_for_template(self, key: str) -> Dict[str, any]:
-        """
-        Get recommended parameters for a template.
-
-        Parameters
-        ----------
-        key : str
-            Template key
-
-        Returns
-        -------
-        dict
-            Dictionary of parameter names and values
-        """
+    def get_parameters_for_template(self, key: str) -> Dict[str, Any]:
+        """Get recommended parameters for a template."""
         template = self.get_template(key)
         if not template:
             return {}
 
         return {
+            "use_controlnet": template.use_controlnet,
+            "mask_dilation": template.mask_dilation,
             "controlnet_conditioning_scale": template.controlnet_conditioning_scale,
-            "feather_radius": template.feather_radius,
+            "preferred_conditioning": template.preferred_conditioning,
+            "preserve_structure_in_mask": template.preserve_structure_in_mask,
+            "edge_guidance_mode": template.edge_guidance_mode,
             "guidance_scale": template.guidance_scale,
             "num_inference_steps": template.num_inference_steps,
             "strength": template.strength,
-            "preferred_conditioning": template.preferred_conditioning,
-            "preserve_structure_in_mask": template.preserve_structure_in_mask,
-            "enhance_prompt": template.enhance_prompt
+            "feather_radius": template.feather_radius,
+            "enhance_prompt": template.enhance_prompt,
         }
 
     def build_prompt(self, key: str, content: str) -> str:
-        """
-        Build complete prompt from template and user content.
-
-        Parameters
-        ----------
-        key : str
-            Template key
-        content : str
-            User-provided content description
-
-        Returns
-        -------
-        str
-            Formatted prompt with content inserted
-        """
+        """Build complete prompt from template and user content."""
         template = self.get_template(key)
         if not template:
             return content
-
         return template.prompt_template.format(content=content)
 
     def get_negative_prompt(self, key: str) -> str:
-        """
-        Get negative prompt for a template.
-
-        Parameters
-        ----------
-        key : str
-            Template key
-
-        Returns
-        -------
-        str
-            Negative prompt string
-        """
+        """Get negative prompt for a template."""
         template = self.get_template(key)
         if not template:
             return ""
         return template.negative_prompt
 
     def get_usage_tips(self, key: str) -> List[str]:
-        """
-        Get usage tips for a template.
-
-        Parameters
-        ----------
-        key : str
-            Template key
-
-        Returns
-        -------
-        list
-            List of tip strings
-        """
+        """Get usage tips for a template."""
         template = self.get_template(key)
         if not template:
             return []
         return template.usage_tips
 
-    def build_gallery_html(self) -> str:
-        """
-        Build HTML for template gallery display.
-
-        Returns
-        -------
-        str
-            HTML string for Gradio display
-        """
-        html_parts = ['<div class="inpainting-gallery">']
-
-        for category in self.CATEGORIES:
-            templates = self.get_templates_by_category(category)
-            if not templates:
-                continue
+    def get_recommended_models(self, key: str) -> List[str]:
+        """Get recommended models for a template."""
+        template = self.get_template(key)
+        if not template:
+            return ["sdxl_base"]
+        return template.recommended_models
 
-            html_parts.append(f'''
-            <div class="inpainting-category">
-                <h4 class="inpainting-category-title">{category}</h4>
-                <div class="inpainting-grid">
-            ''')
+    def get_example_prompts(self, key: str) -> List[str]:
+        """Get example prompts for a template."""
+        template = self.get_template(key)
+        if not template:
+            return []
+        return template.example_prompts
 
-            for template in sorted(templates, key=lambda t: t.name):
-                html_parts.append(f'''
-                <div class="inpainting-card" data-template="{template.key}">
-                    <span class="inpainting-icon">{template.icon}</span>
-                    <span class="inpainting-name">{template.name}</span>
-                    <span class="inpainting-desc">{template.description[:50]}...</span>
-                </div>
-                ''')
-
-            html_parts.append('</div></div>')
-
-        html_parts.append('</div>')
-        return ''.join(html_parts)
+    def get_primary_recommended_model(self, key: str) -> str:
+        """Get the primary recommended model for a template."""
+        models = self.get_recommended_models(key)
+        return models[0] if models else "sdxl_base"

mask_generator.py

@@ -298,7 +298,7 @@ class MaskGenerator:
             # High confidence areas - keep at full opacity
             final_alpha[high_confidence] = 255
 
-            # Medium confidence - boost significantly 
+            # Medium confidence - boost significantly
             final_alpha[medium_confidence] = np.clip(alpha_stretched[medium_confidence] * 1.8, 200, 255)
 
             # Low confidence - moderate boost (catches faint extremities)

scene_templates.py

@@ -24,7 +24,7 @@ class SceneTemplateManager:
 
     # Scene template definitions
     TEMPLATES: Dict[str, SceneTemplate] = {
-        # Professional Category 
+        # Professional Category
         "office_modern": SceneTemplate(
             key="office_modern",
             name="Modern Office",
@@ -71,7 +71,7 @@ class SceneTemplateManager:
             guidance_scale=7.5
         ),
 
-        # Nature Category 
+        # Nature Category
         "beach_sunset": SceneTemplate(
             key="beach_sunset",
             name="Sunset Beach",
@@ -127,7 +127,7 @@ class SceneTemplateManager:
             guidance_scale=7.0
         ),
 
-        # Urban Category 
+        # Urban Category
         "city_skyline": SceneTemplate(
             key="city_skyline",
             name="City Skyline",
@@ -174,7 +174,7 @@ class SceneTemplateManager:
             guidance_scale=7.5
         ),
 
-        # Artistic Category 
+        # Artistic Category
         "gradient_soft": SceneTemplate(
             key="gradient_soft",
             name="Soft Gradient",
@@ -212,7 +212,7 @@ class SceneTemplateManager:
             guidance_scale=6.5
         ),
 
-        # Seasonal Category 
+        # Seasonal Category
         "autumn_foliage": SceneTemplate(
             key="autumn_foliage",
             name="Autumn Foliage",
@@ -425,4 +425,4 @@ class SceneTemplateManager:
                 grid-template-columns: repeat(3, 1fr);
             }
         }
-        """
+        """

scene_weaver_core.py

@@ -321,7 +321,7 @@ class SceneWeaverCore:
             # Analyze image characteristics
             img_array = np.array(foreground_image.convert('RGB'))
 
-            # Analyze color temperature 
+            # Analyze color temperature
             # Convert to LAB to analyze color temperature
             lab = cv2.cvtColor(img_array, cv2.COLOR_RGB2LAB)
             avg_a = np.mean(lab[:, :, 1])  # a channel: green(-) to red(+)
@@ -330,12 +330,12 @@ class SceneWeaverCore:
             # Determine warm/cool tone
             is_warm = avg_b > 128  # b > 128 means more yellow/warm
 
-            # Analyze brightness 
+            # Analyze brightness
             gray = cv2.cvtColor(img_array, cv2.COLOR_RGB2GRAY)
             avg_brightness = np.mean(gray)
             is_bright = avg_brightness > 127
 
-            # Get subject type from CLIP 
+            # Get subject type from CLIP
             clip_analysis = self.analyze_image_with_clip(foreground_image)
             subject_type = "unknown"
 
@@ -369,7 +369,7 @@ class SceneWeaverCore:
 
             quality_modifiers = "high quality, detailed, sharp focus, photorealistic"
 
-            # Select appropriate fragments 
+            # Select appropriate fragments
             # Lighting based on color temperature and brightness
             if is_warm and is_bright:
                 lighting = lighting_options["warm_bright"]
@@ -383,7 +383,7 @@ class SceneWeaverCore:
             # Atmosphere based on subject type
             atmosphere = atmosphere_options.get(subject_type, atmosphere_options["unknown"])
 
-            # Check for conflicts in user prompt 
+            # Check for conflicts in user prompt
             user_prompt_lower = user_prompt.lower()
 
             # Avoid adding conflicting descriptions
@@ -392,7 +392,7 @@ class SceneWeaverCore:
             if "dark" in user_prompt_lower or "night" in user_prompt_lower:
                 lighting = lighting.replace("bright", "").replace("daylight", "")
 
-            # Combine enhanced prompt 
+            # Combine enhanced prompt
             fragments = [user_prompt]
 
             if lighting:
@@ -864,25 +864,33 @@ class SceneWeaverCore:
         """
         if self._inpainting_module is None:
             self._inpainting_module = InpaintingModule(device=self.device)
-            self._inpainting_module.set_model_manager(self._model_manager)
             logger.info("InpaintingModule created (lazy load)")
 
         return self._inpainting_module
 
     def switch_to_inpainting_mode(
         self,
+        use_controlnet: bool = True,
         conditioning_type: str = "canny",
+        model_key: str = "sdxl_base",
         progress_callback: Optional[Callable[[str, int], None]] = None
     ) -> bool:
         """
         Switch to inpainting mode, unloading background pipeline.
 
-        Implements mutual exclusion between pipelines to conserve memory.
+        Supports dual-mode inpainting:
+        - Pure Inpainting (use_controlnet=False): For object replacement/removal
+        - ControlNet Inpainting (use_controlnet=True): For clothing/color change
 
         Parameters
         ----------
+        use_controlnet : bool
+            If False, use dedicated SDXL Inpainting model
+            If True, use ControlNet + SDXL model
         conditioning_type : str
-            ControlNet conditioning type: "canny" or "depth"
+            ControlNet conditioning type: "canny" or "depth" (only for ControlNet mode)
+        model_key : str
+            Model key for ControlNet mode base model
         progress_callback : callable, optional
             Progress update function(message, percentage)
 
@@ -891,7 +899,8 @@ class SceneWeaverCore:
         bool
             True if switch was successful
         """
-        logger.info(f"Switching to inpainting mode (conditioning: {conditioning_type})")
+        mode_str = "ControlNet" if use_controlnet else "Pure Inpainting"
+        logger.info(f"Switching to inpainting mode: {mode_str} (model: {model_key})")
 
         try:
             # Unload background pipeline first
@@ -912,12 +921,14 @@ class SceneWeaverCore:
 
             def inpaint_progress(msg, pct):
                 if progress_callback:
-                    # Map inpainting progress (0-100) to (20-90)
                     mapped_pct = 20 + int(pct * 0.7)
                     progress_callback(msg, mapped_pct)
 
-            success, error_msg = inpaint_module.load_inpainting_pipeline(
+            # Use the new load_pipeline method with dual-mode support
+            success, error_msg = inpaint_module.load_pipeline(
+                use_controlnet=use_controlnet,
                 conditioning_type=conditioning_type,
+                model_key=model_key,
                 progress_callback=inpaint_progress
             )
 
@@ -997,6 +1008,7 @@ class SceneWeaverCore:
         prompt: str,
         preview_only: bool = False,
         template_key: Optional[str] = None,
+        model_key: str = "sdxl_base",
         progress_callback: Optional[Callable[[str, int], None]] = None,
         **kwargs
     ) -> Dict[str, Any]:
@@ -1017,6 +1029,8 @@ class SceneWeaverCore:
             If True, generate quick preview only
         template_key : str, optional
             Inpainting template key to use
+        model_key : str
+            Model key for the base model (juggernaut_xl, realvis_xl, sdxl_base, animagine_xl)
         progress_callback : callable, optional
             Progress update function
         **kwargs
@@ -1027,10 +1041,30 @@ class SceneWeaverCore:
         dict
             Result dictionary with images and metadata
         """
-        # Ensure inpainting mode is active
-        if self._current_mode != "inpainting" or not self._inpainting_initialized:
-            conditioning = kwargs.get('conditioning_type', 'canny')
-            if not self.switch_to_inpainting_mode(conditioning, progress_callback):
+        # Get pipeline mode from kwargs
+        use_controlnet = kwargs.get('use_controlnet', True)
+        conditioning_type = kwargs.get('conditioning_type', 'canny')
+
+        # Check if we need to reinitialize
+        inpaint_module = self.get_inpainting_module()
+        current_mode = getattr(inpaint_module, '_current_mode', None)
+        current_model = getattr(inpaint_module, '_current_model_key', None)
+
+        expected_mode = "controlnet" if use_controlnet else "pure"
+        needs_reinit = (
+            self._current_mode != "inpainting" or
+            not self._inpainting_initialized or
+            current_mode != expected_mode or
+            (use_controlnet and current_model != model_key)
+        )
+
+        if needs_reinit:
+            if not self.switch_to_inpainting_mode(
+                use_controlnet=use_controlnet,
+                conditioning_type=conditioning_type,
+                model_key=model_key,
+                progress_callback=progress_callback
+            ):
                 error_detail = getattr(self, '_last_inpainting_error', 'Unknown error')
                 return {
                     "success": False,
@@ -1038,33 +1072,11 @@ class SceneWeaverCore:
                 }
 
         inpaint_module = self.get_inpainting_module()
-
-        # Apply template if specified
-        if template_key:
-            template_mgr = InpaintingTemplateManager()
-            template = template_mgr.get_template(template_key)
-
-            if template:
-                # Build prompt from template
-                prompt = template_mgr.build_prompt(template_key, prompt)
-                # Apply template parameters as defaults
-                params = template_mgr.get_parameters_for_template(template_key)
-                for key, value in params.items():
-                    if key not in kwargs:
-                        kwargs[key] = value
-
-                # Pass enhance_prompt flag to inpainting module
-                if 'enhance_prompt' not in kwargs:
-                    kwargs['enhance_prompt'] = template.enhance_prompt
-
-        # Execute inpainting
         result = inpaint_module.execute_inpainting(
             image=image,
             mask=mask,
             prompt=prompt,
-            preview_only=preview_only,
             progress_callback=progress_callback,
-            template_key=template_key,  # Pass template_key for conditional prompt enhancement
             **kwargs
         )
 
@@ -1191,4 +1203,4 @@ class SceneWeaverCore:
 
         status = self._inpainting_module.get_status()
         status["mode"] = self._current_mode
-        return status
+        return status

ui_manager.py

@@ -3,16 +3,17 @@ import time
 import traceback
 from pathlib import Path
 from typing import Optional, Tuple, Dict, Any, List
-from PIL import Image
-import numpy as np
+
 import cv2
 import gradio as gr
-import spaces
+import numpy as np
+from PIL import Image
 
-from scene_weaver_core import SceneWeaverCore
 from css_styles import CSSStyles
 from scene_templates import SceneTemplateManager
 from inpainting_templates import InpaintingTemplateManager
+from scene_weaver_core import SceneWeaverCore
+from gpu_handlers import GPUHandlers
 
 logger = logging.getLogger(__name__)
 logger.setLevel(logging.INFO)
@@ -29,16 +30,20 @@ class UIManager:
     Gradio UI Manager with support for background generation and inpainting.
 
     Provides a professional interface with mode switching, template selection,
-    and advanced parameter controls.
+    and advanced parameter controls. GPU operations are delegated to GPUHandlers.
 
     Attributes:
-        sceneweaver: SceneWeaverCore instance
+        gpu_handlers: GPUHandlers instance for GPU operations
         template_manager: Scene template manager
         inpainting_template_manager: Inpainting template manager
     """
 
     def __init__(self):
         self.sceneweaver = SceneWeaverCore()
+        self.gpu_handlers = GPUHandlers(
+            core=self.sceneweaver,
+            inpainting_template_manager=InpaintingTemplateManager()
+        )
         self.template_manager = SceneTemplateManager()
         self.inpainting_template_manager = InpaintingTemplateManager()
         self.generation_history = []
@@ -173,7 +178,6 @@ class UIManager:
         if len(self.generation_history) > max_history:
             self.generation_history = self.generation_history[-max_history:]
 
-    @spaces.GPU(duration=240)
     def generate_handler(
         self,
         uploaded_image: Optional[Image.Image],
@@ -185,8 +189,33 @@ class UIManager:
         guidance: float,
         progress=gr.Progress()
     ):
-        """Enhanced generation handler with memory management and ZeroGPU support"""
+        """
+        Generation handler - delegates GPU work to GPUHandlers.
 
+        Parameters
+        ----------
+        uploaded_image : PIL.Image
+            Input image
+        prompt : str
+            Background description
+        combination_mode : str
+            Composition mode
+        focus_mode : str
+            Focus mode
+        negative_prompt : str
+            Negative prompt
+        steps : int
+            Inference steps
+        guidance : float
+            Guidance scale
+        progress : gr.Progress
+            Progress callback
+
+        Returns
+        -------
+        tuple
+            (combined, generated, original, status, download_btn_update)
+        """
         if uploaded_image is None:
             return None, None, None, "Please upload an image to get started!", gr.update(visible=False)
 
@@ -194,44 +223,19 @@ class UIManager:
             return None, None, None, "Please describe the background scene you'd like!", gr.update(visible=False)
 
         try:
-            if not self.sceneweaver.is_initialized:
-                progress(0.05, desc="Loading AI models (first time may take 2-3 minutes)...")
-
-                def init_progress(msg, pct):
-                    if pct < 30:
-                        desc = "Loading image analysis models..."
-                    elif pct < 60:
-                        desc = "Loading Stable Diffusion XL..."
-                    elif pct < 90:
-                        desc = "Applying memory optimizations..."
-                    else:
-                        desc = "Almost ready..."
-                    progress(0.05 + (pct/100) * 0.2, desc=desc)
-
-                self.sceneweaver.load_models(progress_callback=init_progress)
-
-            def gen_progress(msg, pct):
-                if pct < 20:
-                    desc = "Analyzing your image..."
-                elif pct < 50:
-                    desc = "Generating background scene..."
-                elif pct < 80:
-                    desc = "Blending foreground and background..."
-                elif pct < 95:
-                    desc = "Applying final touches..."
-                else:
-                    desc = "Complete!"
-                progress(0.25 + (pct/100) * 0.75, desc=desc)
+            def progress_callback(msg: str, pct: int):
+                progress(pct / 100, desc=msg)
 
-            result = self.sceneweaver.generate_and_combine(
-                original_image=uploaded_image,
+            # Delegate to GPUHandlers
+            result = self.gpu_handlers.background_generate(
+                image=uploaded_image,
                 prompt=prompt,
-                combination_mode=combination_mode,
-                focus_mode=focus_mode,
                 negative_prompt=negative_prompt,
-                num_inference_steps=int(steps),
+                composition_mode=combination_mode,
+                focus_mode=focus_mode,
+                num_steps=int(steps),
                 guidance_scale=float(guidance),
-                progress_callback=gen_progress
+                progress_callback=progress_callback
             )
 
             if result["success"]:
@@ -547,7 +551,7 @@ class UIManager:
         self,
         display_name: str,
         current_prompt: str
-    ) -> Tuple[str, float, int, str]:
+    ) -> Tuple[str, float, int, str, Any, Any, Any]:
         """
         Apply an inpainting template to the UI fields.
 
@@ -561,26 +565,76 @@ class UIManager:
         Returns
         -------
         tuple
-            (prompt, conditioning_scale, feather_radius, conditioning_type)
+            (prompt, conditioning_scale, feather_radius, conditioning_type,
+             controlnet_settings_visibility, mode_info_html, model_selection_visibility)
         """
+        # Default returns for no template selected
+        default_return = (
+            current_prompt,
+            0.7,
+            8,
+            "canny",
+            gr.update(visible=True),   # Show ControlNet settings by default
+            "",                         # No mode info
+            gr.update(visible=True)    # Show model selection by default
+        )
+
         if not display_name:
-            return current_prompt, 0.7, 8, "canny"
+            return default_return
 
         template_key = self.inpainting_template_manager.get_template_key_from_display(display_name)
         if not template_key:
-            return current_prompt, 0.7, 8, "canny"
+            return default_return
 
         template = self.inpainting_template_manager.get_template(template_key)
         if template:
             params = self.inpainting_template_manager.get_parameters_for_template(template_key)
+            use_controlnet = params.get('use_controlnet', True)
+
+            # Determine visibility and info based on mode
+            if use_controlnet:
+                controlnet_visibility = gr.update(visible=True)
+                model_visibility = gr.update(visible=True)
+                mode_info = """
+                <div style="background: linear-gradient(135deg, #e8f5e9 0%, #c8e6c9 100%);
+                            border-left: 4px solid #4CAF50;
+                            padding: 10px 14px;
+                            border-radius: 8px;
+                            margin: 8px 0;">
+                    <p style="margin: 0; color: #2e7d32; font-size: 13px;">
+                        🎛️ <strong>ControlNet Mode</strong> - Structure will be preserved using edge/depth guidance.
+                        You can adjust ControlNet settings and select model below.
+                    </p>
+                </div>
+                """
+            else:
+                # Pure Inpainting mode - hide both ControlNet and Model Selection
+                controlnet_visibility = gr.update(visible=False)
+                model_visibility = gr.update(visible=False)
+                mode_info = """
+                <div style="background: linear-gradient(135deg, #fff3e0 0%, #ffe0b2 100%);
+                            border-left: 4px solid #ff9800;
+                            padding: 10px 14px;
+                            border-radius: 8px;
+                            margin: 8px 0;">
+                    <p style="margin: 0; color: #e65100; font-size: 13px;">
+                        🚀 <strong>Pure Inpainting Mode</strong> - Using dedicated SDXL Inpainting model.<br>
+                        Model and ControlNet settings are automatically configured for best results.
+                    </p>
+                </div>
+                """
+
             return (
                 current_prompt,
                 params.get('controlnet_conditioning_scale', 0.7),
                 params.get('feather_radius', 8),
-                params.get('preferred_conditioning', 'canny')
+                params.get('preferred_conditioning', 'canny'),
+                controlnet_visibility,
+                mode_info,
+                model_visibility
             )
 
-        return current_prompt, 0.7, 8, "canny"
+        return default_return
 
     def extract_mask_from_editor(self, editor_output: Dict[str, Any]) -> Optional[Image.Image]:
         """
@@ -664,22 +718,23 @@ class UIManager:
             logger.error(f"Failed to extract mask from editor: {e}")
             return None
 
-    @spaces.GPU(duration=420)
     def inpainting_handler(
         self,
         image: Optional[Image.Image],
         mask_editor: Dict[str, Any],
         prompt: str,
         template_dropdown: str,
+        model_choice: str,
         conditioning_type: str,
         conditioning_scale: float,
         feather_radius: int,
         guidance_scale: float,
         num_steps: int,
+        seed: int,
         progress: gr.Progress = gr.Progress()
-    ) -> Tuple[Optional[Image.Image], Optional[Image.Image], Optional[Image.Image], str]:
+    ) -> Tuple[Optional[Image.Image], Optional[Image.Image], str, int]:
         """
-        Handle inpainting generation request.
+        Handle inpainting generation request - delegates GPU work to GPUHandlers.
 
         Parameters
         ----------
@@ -691,6 +746,8 @@ class UIManager:
             Text description of desired content
         template_dropdown : str
             Selected template (optional)
+        model_choice : str
+            Model key to use (juggernaut_xl, realvis_xl, sdxl_base, animagine_xl)
         conditioning_type : str
             ControlNet conditioning type
         conditioning_scale : float
@@ -701,36 +758,36 @@ class UIManager:
             Guidance scale for generation
         num_steps : int
             Number of inference steps
+        seed : int
+            Random seed (-1 for random)
         progress : gr.Progress
             Progress callback
 
         Returns
         -------
         tuple
-            (result_image, control_image, status_message)
+            (result_image, control_image, status_message, used_seed)
         """
         if image is None:
-            return None, None, "⚠️ Please upload an image first"
+            return None, None, "⚠️ Please upload an image first", -1
 
         # Extract mask
         mask = self.extract_mask_from_editor(mask_editor)
         if mask is None:
-            return None, None, "⚠️ Please draw a mask on the image"
+            return None, None, "⚠️ Please draw a mask on the image", -1
 
         # Validate mask
         mask_array = np.array(mask)
         coverage = np.count_nonzero(mask_array > 127) / mask_array.size
         if coverage < 0.01:
-            return None, None, "⚠️ Mask too small - please select a larger area"
+            return None, None, "⚠️ Mask too small - please select a larger area", -1
         if coverage > 0.95:
-            return None, None, "⚠️ Mask too large - consider using background generation instead"
+            return None, None, "⚠️ Mask too large - consider using background generation instead", -1
 
         def progress_callback(msg: str, pct: int):
             progress(pct / 100, desc=msg)
 
         try:
-            start_time = time.time()
-
             # Get template key if selected
             template_key = None
             if template_dropdown:
@@ -738,53 +795,39 @@ class UIManager:
                     template_dropdown
                 )
 
-            # Execute inpainting through SceneWeaverCore facade
-            result = self.sceneweaver.execute_inpainting(
+            # Delegate to GPUHandlers
+            result_image, control_image, status, used_seed = self.gpu_handlers.inpainting_generate(
                 image=image,
                 mask=mask,
                 prompt=prompt,
-                preview_only=False,
                 template_key=template_key,
+                model_key=model_choice,
                 conditioning_type=conditioning_type,
-                controlnet_conditioning_scale=conditioning_scale,
+                conditioning_scale=conditioning_scale,
                 feather_radius=feather_radius,
                 guidance_scale=guidance_scale,
-                num_inference_steps=num_steps,
+                num_steps=num_steps,
+                seed=int(seed) if seed is not None else -1,
                 progress_callback=progress_callback
             )
 
-            elapsed = time.time() - start_time
-
-            if result.get('success'):
-                # Store in history
+            # Store in history if successful
+            if result_image is not None:
                 self.inpainting_history.append({
-                    'result': result.get('combined_image'),
+                    'result': result_image,
                     'prompt': prompt,
-                    'time': elapsed
+                    'seed': used_seed,
+                    'time': time.time()
                 })
                 if len(self.inpainting_history) > 3:
                     self.inpainting_history.pop(0)
 
-                quality_score = result.get('quality_score', 0)
-
-                # Clean, simple status message
-                status = f"✅ Inpainting complete in {elapsed:.1f}s"
-                if quality_score > 0:
-                    status += f" | Quality: {quality_score:.0f}/100"
-
-                return (
-                    result.get('combined_image'),
-                    result.get('control_image'),
-                    status
-                )
-            else:
-                error_msg = result.get('error', 'Unknown error')
-                return None, None, f"❌ Inpainting failed: {error_msg}"
+            return result_image, control_image, status, used_seed
 
         except Exception as e:
             logger.error(f"Inpainting handler error: {e}")
             logger.error(traceback.format_exc())
-            return None, None, f"❌ Error: {str(e)}"
+            return None, None, f"❌ Error: {str(e)}", -1
 
     def create_inpainting_tab(self) -> gr.Tab:
         """
@@ -812,17 +855,44 @@ class UIManager:
                     </span>
                 </h3>
                 <p style="color: #666; margin-bottom: 12px;">Draw a mask to select the area you want to regenerate</p>
-                <div style="background: linear-gradient(to right, #FFF4E6, #FFE8CC);
-                            border-left: 4px solid #FF9500;
-                            padding: 12px 15px;
-                            border-radius: 6px;
-                            margin-top: 10px;
-                            box-shadow: 0 2px 4px rgba(255, 149, 0, 0.1);">
-                    <p style="color: #8B4513; font-size: 0.9em; margin: 0; line-height: 1.5;">
-                        <strong>⚠️ Beta Feature - Continuously Optimizing</strong><br>
-                        Results may vary depending on complexity. Use templates and detailed prompts for best results.
-                        Advanced features (like Add Accessories) may require multiple attempts.
-                    </p>
+            </div>
+            """)
+
+            # Model Selection Guide
+            gr.HTML("""
+            <div style="background: linear-gradient(135deg, #f5f7fa 0%, #e4e8ec 100%);
+                        padding: 16px;
+                        border-radius: 12px;
+                        margin: 12px 0;
+                        border: 1px solid #ddd;">
+                <h4 style="margin: 0 0 12px 0; color: #333; font-size: 16px;">
+                    📸 Model Selection Guide
+                </h4>
+                <div style="display: grid; grid-template-columns: 1fr 1fr; gap: 12px;">
+                    <div style="background: white; padding: 12px; border-radius: 8px; border-left: 4px solid #4CAF50;">
+                        <p style="margin: 0 0 8px 0; font-weight: bold; color: #4CAF50;">
+                            🖼️ Photo Mode (Real Photos)
+                        </p>
+                        <p style="margin: 0; font-size: 13px; color: #555;">
+                            <strong>Best for:</strong> Photographs, portraits, product shots, nature photos
+                        </p>
+                        <p style="margin: 8px 0 0 0; font-size: 12px; color: #777;">
+                            • <strong>JuggernautXL</strong> - Best for portraits and people<br>
+                            • <strong>RealVisXL</strong> - Best for scenes and objects
+                        </p>
+                    </div>
+                    <div style="background: white; padding: 12px; border-radius: 8px; border-left: 4px solid #9C27B0;">
+                        <p style="margin: 0 0 8px 0; font-weight: bold; color: #9C27B0;">
+                            🎨 Anime Mode (Illustrations)
+                        </p>
+                        <p style="margin: 0; font-size: 13px; color: #555;">
+                            <strong>Best for:</strong> Anime, manga, illustrations, digital art, cartoons
+                        </p>
+                        <p style="margin: 8px 0 0 0; font-size: 12px; color: #777;">
+                            • <strong>Animagine XL</strong> - Best for anime/manga style<br>
+                            • <strong>SDXL Base</strong> - Versatile for general art
+                        </p>
+                    </div>
                 </div>
             </div>
             """)
@@ -859,6 +929,9 @@ class UIManager:
                         )
                         template_tips = gr.Markdown("")
 
+                    # Mode info (dynamically updated based on template)
+                    mode_info_html = gr.HTML("")
+
                     # Prompt
                     inpaint_prompt = gr.Textbox(
                         label="Prompt",
@@ -868,28 +941,49 @@ class UIManager:
 
                 # Right column - Settings and Output
                 with gr.Column(scale=1):
-                    # Settings
-                    with gr.Accordion("Generation Settings", open=True):
-                        conditioning_type = gr.Radio(
-                            choices=["canny", "depth"],
-                            value="canny",
-                            label="ControlNet Mode"
-                        )
+                    # Model Selection (hidden for Pure Inpainting templates)
+                    with gr.Group(visible=True) as model_selection_group:
+                        with gr.Accordion("Model Selection", open=True):
+                            model_choice = gr.Dropdown(
+                                choices=[
+                                    ("🖼️ JuggernautXL v9 - Best for portraits & real photos", "juggernaut_xl"),
+                                    ("🖼️ RealVisXL v4 - Best for realistic scenes", "realvis_xl"),
+                                    ("🎨 SDXL Base - Versatile for general art", "sdxl_base"),
+                                    ("🎨 Animagine XL 3.1 - Best for anime/manga", "animagine_xl"),
+                                ],
+                                value="juggernaut_xl",
+                                label="Select Model",
+                                info="Choose based on your image type (photo vs illustration)"
+                            )
 
-                        conditioning_scale = gr.Slider(
-                            minimum=0.05,
-                            maximum=1.0,
-                            value=0.7,
-                            step=0.05,
-                            label="ControlNet Strength"
-                        )
+                    # ControlNet Settings (hidden for Pure Inpainting templates)
+                    with gr.Group(visible=True) as controlnet_settings_group:
+                        with gr.Accordion("ControlNet Settings", open=True):
+                            conditioning_type = gr.Radio(
+                                choices=["canny", "depth"],
+                                value="canny",
+                                label="ControlNet Mode",
+                                info="Canny: preserves edges | Depth: preserves 3D structure"
+                            )
+
+                            conditioning_scale = gr.Slider(
+                                minimum=0.05,
+                                maximum=1.0,
+                                value=0.7,
+                                step=0.05,
+                                label="ControlNet Strength",
+                                info="Higher = more structure preservation"
+                            )
 
+                    # General Settings (always visible)
+                    with gr.Accordion("General Settings", open=True):
                         feather_radius = gr.Slider(
                             minimum=0,
                             maximum=20,
                             value=8,
                             step=1,
-                            label="Feather Radius (px)"
+                            label="Feather Radius (px)",
+                            info="Edge blending softness"
                         )
 
                     with gr.Accordion("Advanced Settings", open=False):
@@ -909,6 +1003,14 @@ class UIManager:
                             label="Inference Steps"
                         )
 
+                        # Seed control for reproducibility
+                        seed_input = gr.Number(
+                            label="Seed",
+                            value=-1,
+                            precision=0,
+                            info="-1 = random seed, or enter a specific number to reproduce results"
+                        )
+
                     # Generate button
                     inpaint_btn = gr.Button(
                         "Generate Inpainting",
@@ -925,9 +1027,9 @@ class UIManager:
                                     border-radius: 8px;
                                     margin: 12px 0;">
                             <p style="margin: 0; color: #5d4037; font-size: 14px;">
-                                ⏳ <strong>Please be patient!</strong> Inpainting typically takes <strong>5-7 minutes</strong>
-                                depending on GPU availability and image complexity.
-                                Please don't refresh the page while processing.
+                                ⏳ <strong>Please be patient!</strong><br>
+                                • <strong>First run:</strong> 5-7 minutes (model initialization)<br>
+                                • <strong>Subsequent runs:</strong> 2-3 minutes (model cached)
                             </p>
                         </div>
                         <div style="background: linear-gradient(135deg, #e3f2fd 0%, #bbdefb 100%);
@@ -943,13 +1045,27 @@ class UIManager:
                         """
                     )
 
-                    # Status
+                    # Status and Seed display
                     inpaint_status = gr.Textbox(
                         label="Status",
                         value="Ready for inpainting",
                         interactive=False
                     )
 
+                    # Display used seed for reproducibility
+                    with gr.Row():
+                        used_seed_display = gr.Number(
+                            label="Used Seed (copy this to reproduce)",
+                            value=-1,
+                            precision=0,
+                            interactive=False
+                        )
+                        copy_seed_btn = gr.Button(
+                            "📋 Use This Seed",
+                            size="sm",
+                            scale=0
+                        )
+
             # Output row
             with gr.Row():
                 with gr.Column(scale=1):
@@ -971,7 +1087,15 @@ class UIManager:
             inpaint_template.change(
                 fn=self.apply_inpainting_template,
                 inputs=[inpaint_template, inpaint_prompt],
-                outputs=[inpaint_prompt, conditioning_scale, feather_radius, conditioning_type]
+                outputs=[
+                    inpaint_prompt,
+                    conditioning_scale,
+                    feather_radius,
+                    conditioning_type,
+                    controlnet_settings_group,
+                    mode_info_html,
+                    model_selection_group
+                ]
             )
 
             inpaint_template.change(
@@ -980,9 +1104,16 @@ class UIManager:
                 outputs=[template_tips]
             )
 
-            # Copy uploaded image to mask editor
+            # Copy uploaded image to mask editor (as background)
+            def set_mask_editor_background(image):
+                """Set uploaded image as mask editor background."""
+                if image is None:
+                    return None
+                # Return dict format for ImageEditor with background
+                return {"background": image, "layers": [], "composite": None}
+
             inpaint_image.change(
-                fn=lambda x: x,
+                fn=set_mask_editor_background,
                 inputs=[inpaint_image],
                 outputs=[mask_editor]
             )
@@ -994,19 +1125,29 @@ class UIManager:
                     mask_editor,
                     inpaint_prompt,
                     inpaint_template,
+                    model_choice,
                     conditioning_type,
                     conditioning_scale,
                     feather_radius,
                     inpaint_guidance,
-                    inpaint_steps
+                    inpaint_steps,
+                    seed_input
                 ],
                 outputs=[
                     inpaint_result,
                     inpaint_control,
-                    inpaint_status
+                    inpaint_status,
+                    used_seed_display
                 ]
             )
 
+            # Copy seed button - copies used seed to input
+            copy_seed_btn.click(
+                fn=lambda x: x,
+                inputs=[used_seed_display],
+                outputs=[seed_input]
+            )
+
         return tab
 
     def _get_template_tips(self, display_name: str) -> str:
@@ -1021,4 +1162,4 @@ class UIManager:
         tips = self.inpainting_template_manager.get_usage_tips(template_key)
         if tips:
             return "**Tips:**\n" + "\n".join(f"- {tip}" for tip in tips)
-        return ""
+        return ""