Upload 4 files

initial commit of files

Stencil.py

@@ -0,0 +1,326 @@
+"""
+Stencil Image Generator using Stable Diffusion
+
+This module provides a simple interface to generate drawing stencil images
+using pretrained Stable Diffusion models with prompt engineering.
+"""
+
+import torch
+from diffusers import StableDiffusionPipeline, DPMSolverMultistepScheduler
+from PIL import Image, ImageOps, ImageEnhance, ImageFilter
+from typing import Optional, List, Union
+import os
+import numpy as np
+from scipy import ndimage
+
+
+def _patch_clip_init():
+    """
+    Monkey-patch CLIPTextModel.__init__ to ignore offload_state_dict parameter.
+    This fixes compatibility issues between mismatched transformers versions.
+    """
+    try:
+        from transformers import CLIPTextModel
+        original_init = CLIPTextModel.__init__
+
+        def patched_init(self, config, *args, **kwargs):
+            # Remove the offload_state_dict parameter if it exists
+            kwargs.pop('offload_state_dict', None)
+            return original_init(self, config, *args, **kwargs)
+
+        CLIPTextModel.__init__ = patched_init
+    except ImportError:
+        pass  # transformers not installed yet
+
+
+class StencilGenerator:
+    """
+    A class to generate drawing stencil images using Stable Diffusion.
+
+    This generator automatically appends stencil-specific prompt decorations
+    to guide the model toward producing black and white stencil-style images.
+    """
+
+    def __init__(
+        self,
+        model_id: str = "stabilityai/stable-diffusion-2-1-base",
+        device: Optional[str] = None,
+        use_fp16: bool = True
+    ):
+        """
+        Initialize the Stencil Generator.
+
+        Args:
+            model_id: HuggingFace model ID for Stable Diffusion model
+            device: Device to run on ('cuda', 'cpu', or None for auto-detect)
+            use_fp16: Whether to use half precision (FP16) for faster inference
+        """
+        self.model_id = model_id
+        self.device = device or ("cuda" if torch.cuda.is_available() else "cpu")
+        self.use_fp16 = use_fp16 and self.device == "cuda"
+
+        # Apply monkey-patch to fix transformers version compatibility
+        _patch_clip_init()
+
+        print(f"Loading model {model_id} on {self.device}...")
+
+        # Load the pipeline with version-compatible parameters
+        dtype = torch.float16 if self.use_fp16 else torch.float32
+
+        self.pipe = StableDiffusionPipeline.from_pretrained(
+            model_id,
+            torch_dtype=dtype,
+            safety_checker=None,  # Disable for faster loading
+        )
+
+        # Use DPM-Solver for faster generation
+        self.pipe.scheduler = DPMSolverMultistepScheduler.from_config(
+            self.pipe.scheduler.config
+        )
+
+        self.pipe = self.pipe.to(self.device)
+
+        # Enable memory optimizations
+        if self.device == "cuda":
+            self.pipe.enable_attention_slicing()
+            # Uncomment if you have limited VRAM
+            # self.pipe.enable_vae_slicing()
+
+        print("Model loaded successfully!")
+
+        # Default stencil prompt suffix - simplified since post-processing does the heavy lifting
+        self.stencil_suffix = (
+            "black silhouette, high contrast, simple stencil design, "
+            "centered in frame, complete object visible, isolated subject"
+        )
+
+        # Default negative prompt to avoid unwanted features
+        # self.default_negative_prompt = (
+        #     "color, colorful, photograph, realistic, detailed, complex, "
+        #     "blurry, low quality, watermark, text, cropped, cut off, "
+        #     "partial, multiple subjects, duplicate"
+        # )
+
+        # Simpler stencil prompt suffix (seems to work better) - simplified since post-processing does the heavy lifting
+        # self.stencil_suffix = (
+        #     "black silhouette, high contrast, sketch line drawing, simple, simple stencil design, white background, "
+        #     # "centered in frame, complete object visible, isolated subject"
+        # )
+
+        # Simpler negative prompt (seems to work better) to avoid unwanted features
+        self.default_negative_prompt = (
+            "color, colorful, photograph, realistic, detailed, complex, "
+            # "blurry, low quality, watermark, text, cropped, cut off, "
+            # "partial, multiple subjects, duplicate"
+        )
+
+    def _clean_stencil_image(
+        self,
+        image: Image.Image,
+        binary_threshold: int = 128,
+        invert_if_needed: bool = True,
+        remove_small_objects: bool = True,
+        min_object_size: int = 100
+    ) -> Image.Image:
+        """
+        Aggressively convert any image to a clean binary stencil.
+        This uses Otsu's method and morphological operations to force
+        a clean black silhouette on pure white background, regardless
+        of what the model generated.
+
+        Args:
+            image: Input PIL Image
+            binary_threshold: Threshold for binarization (0-255), 128 = middle
+            invert_if_needed: Auto-detect if we need to invert (black on white vs white on black)
+            remove_small_objects: Remove small noise/artifacts
+            min_object_size: Minimum pixel area to keep (removes noise)
+
+        Returns:
+            Pure black and white stencil image
+        """
+        # Convert to grayscale first
+        if image.mode != 'L':
+            image = image.convert('L')
+
+        # Convert to numpy array
+        img_array = np.array(image)
+
+        # Apply Otsu's method for automatic threshold detection
+        # This finds the optimal threshold to separate foreground/background
+        try:
+            from skimage.filters import threshold_otsu
+            binary_threshold = threshold_otsu(img_array)
+        except ImportError:
+            # Fall back to simple threshold if skimage not available
+            binary_threshold = 128
+
+        # Apply binary threshold - create stark black and white
+        binary = img_array > binary_threshold
+
+        # Decide if we need to invert (we want black subject on white background)
+        if invert_if_needed:
+            # Count pixels - if more white than black, we likely have black subject on white (correct)
+            # If more black than white, we have white subject on black (need to invert)
+            white_pixels = np.sum(binary)
+            total_pixels = binary.size
+            if white_pixels < total_pixels / 2:
+                # More black than white - invert
+                binary = ~binary
+
+        # Remove small objects (noise/artifacts)
+        if remove_small_objects:
+            try:
+                from scipy.ndimage import label, sum as ndi_sum
+                # Label connected components
+                labeled_array, num_features = label(~binary)  # Invert for labeling dark regions
+
+                # Calculate size of each component
+                component_sizes = ndi_sum(~binary, labeled_array, range(num_features + 1))
+
+                # Remove small components
+                mask_size = component_sizes < min_object_size
+                remove_pixel = mask_size[labeled_array]
+                binary[remove_pixel] = True  # Set to white (background)
+            except ImportError:
+                pass  # Skip if scipy not available
+
+        # Apply slight morphological closing to fill small holes in the subject
+        try:
+            from scipy.ndimage import binary_closing
+            binary = binary_closing(binary, structure=np.ones((3, 3)))
+        except ImportError:
+            pass
+
+        # Convert boolean array to uint8 (True->255, False->0)
+        result = (binary * 255).astype(np.uint8)
+
+        # Convert back to PIL Image
+        cleaned_image = Image.fromarray(result, mode='L').convert('RGB')
+
+        return cleaned_image
+
+    
+
+    def generate(
+        self,
+        prompt: str,
+        num_images: int = 1,
+        negative_prompt: Optional[str] = None,
+        num_inference_steps: int = 25,
+        guidance_scale: float = 7.5,
+        width: int = 512,
+        height: int = 512,
+        seed: Optional[int] = None,
+        add_stencil_suffix: bool = True,
+        clean_background: bool = True,
+    ) -> Union[Image.Image, List[Image.Image]]:
+        """
+        Generate stencil images based on the prompt.
+
+        Args:
+            prompt: Base text prompt describing what to draw
+            negative_prompt: Things to avoid in the generation
+            num_images: Number of images to generate
+            num_inference_steps: Number of denoising steps (higher = better quality, slower)
+            guidance_scale: How strongly to follow the prompt (7-8 recommended)
+            width: Image width in pixels (must be divisible by 8)
+            height: Image height in pixels (must be divisible by 8)
+            seed: Random seed for reproducibility (None for random)
+            add_stencil_suffix: Whether to automatically add stencil styling to prompt
+            clean_background: Whether to post-process into pure binary stencil (highly recommended)
+
+        Returns:
+            Single PIL Image if num_images=1, otherwise list of PIL Images
+        """
+
+
+        # Construct full prompt
+        full_prompt = prompt
+        if add_stencil_suffix:
+            full_prompt = f"{prompt}, {self.stencil_suffix}"
+
+        # Use default negative prompt if none provided
+        full_negative_prompt = negative_prompt or self.default_negative_prompt
+
+        # Set seed if provided
+        generator = None
+        if seed is not None:
+            generator = torch.Generator(device=self.device).manual_seed(seed)
+
+        print(f"Generating {num_images} stencil image(s)...")
+        print(f"Prompt: {full_prompt}")
+
+        # Generate images
+        with torch.autocast(self.device) if self.use_fp16 else torch.no_grad():
+            result = self.pipe(
+                prompt=full_prompt,
+                num_images_per_prompt=num_images,
+                negative_prompt=full_negative_prompt,
+                num_inference_steps=num_inference_steps,
+                guidance_scale=guidance_scale,
+                width=width,
+                height=height,
+                generator=generator,
+            )
+
+        images = result.images
+
+        # Apply post-processing to clean background if enabled
+        if clean_background:
+            print("Cleaning background...")
+            images = [self._clean_stencil_image(img) for img in images]
+
+        print("Generation complete!")
+
+        # Return single image or list
+        return images[0] if num_images == 1 else images
+
+    def save_image(
+        self,
+        image: Image.Image,
+        output_path: str,
+        create_dirs: bool = True
+    ):
+        """
+        Save a generated image to disk.
+
+        Args:
+            image: PIL Image to save
+            output_path: Path where to save the image
+            create_dirs: Whether to create parent directories if they don't exist
+        """
+        if create_dirs:
+            os.makedirs(os.path.dirname(output_path) or ".", exist_ok=True)
+
+        image.save(output_path)
+        print(f"Image saved to: {output_path}")
+
+    def generate_and_save(
+        self,
+        prompt: str,
+        output_path: str,
+        num_images: int = 1,
+        **kwargs
+    ) -> Image.Image:
+        """
+        Generate a stencil image and save it to disk in one call.
+
+        Args:
+            prompt: Base text prompt describing what to draw
+            output_path: Path where to save the image
+            **kwargs: Additional arguments passed to generate()
+
+        Returns:
+            The generated PIL Image
+        """
+        image = self.generate(prompt, num_images, **kwargs)
+        # Save single or multiple images
+        # if numb images is 1, save directly, else save with index suffix
+        if num_images == 1:
+            self.save_image(image, output_path)
+        else:
+            for idx, img in enumerate(image):
+                path = output_path.replace(".png", f"_{idx+1}.png")
+                self.save_image(img, path)
+        return image
+

StencilCV.py

@@ -0,0 +1,369 @@
+"""
+StencilCV - Traditional Computer Vision Approach to Stencil Generation
+
+This module uses classical computer vision techniques (edge detection, contours,
+thresholding) to convert images into clean stencils. No AI required - fast,
+deterministic, and reliable.
+
+Approaches:
+1. Edge detection (Canny) - creates outline stencils
+2. Contour extraction - creates filled silhouette stencils
+3. Threshold-based - converts to binary black/white
+"""
+
+import cv2
+import numpy as np
+from PIL import Image
+from typing import Union, Literal
+import os
+
+
+class StencilCV:
+    """
+    Computer vision-based stencil generator.
+
+    Converts any input image (photo, drawing, etc.) into a clean stencil
+    using traditional image processing techniques.
+    """
+
+    def __init__(self):
+        """Initialize the StencilCV processor."""
+        pass
+
+    def load_image(self, image_path: str) -> np.ndarray:
+        """
+        Load an image from file.
+
+        Args:
+            image_path: Path to input image
+
+        Returns:
+            Image as numpy array (BGR format)
+        """
+        img = cv2.imread(image_path)
+        if img is None:
+            raise ValueError(f"Could not load image from {image_path}")
+        return img
+
+    def from_pil(self, pil_image: Image.Image) -> np.ndarray:
+        """
+        Convert PIL Image to OpenCV format.
+
+        Args:
+            pil_image: PIL Image object
+
+        Returns:
+            Image as numpy array (BGR format)
+        """
+        # Convert PIL (RGB) to OpenCV (BGR)
+        return cv2.cvtColor(np.array(pil_image), cv2.COLOR_RGB2BGR)
+
+    def to_pil(self, cv_image: np.ndarray) -> Image.Image:
+        """
+        Convert OpenCV image to PIL Image.
+
+        Args:
+            cv_image: OpenCV image (BGR or grayscale)
+
+        Returns:
+            PIL Image object
+        """
+        if len(cv_image.shape) == 2:  # Grayscale
+            return Image.fromarray(cv_image)
+        else:  # BGR to RGB
+            return Image.fromarray(cv2.cvtColor(cv_image, cv2.COLOR_BGR2RGB))
+
+    def edge_stencil(
+        self,
+        image: Union[str, np.ndarray, Image.Image],
+        blur_kernel: int = 5,
+        canny_low: int = 50,
+        canny_high: int = 150,
+        line_thickness: int = 2,
+        invert: bool = False
+    ) -> Image.Image:
+        """
+        Create outline stencil using Canny edge detection.
+        Perfect for line art, coloring book style stencils.
+
+        Args:
+            image: Input image (path, numpy array, or PIL Image)
+            blur_kernel: Gaussian blur kernel size (reduces noise)
+            canny_low: Canny edge detection low threshold
+            canny_high: Canny edge detection high threshold
+            line_thickness: Thickness of edge lines
+            invert: If True, white lines on black; if False, black lines on white
+
+        Returns:
+            PIL Image with edge-based stencil
+        """
+        # Load image
+        if isinstance(image, str):
+            img = self.load_image(image)
+        elif isinstance(image, Image.Image):
+            img = self.from_pil(image)
+        else:
+            img = image.copy()
+
+        # Convert to grayscale
+        gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
+
+        # Apply Gaussian blur to reduce noise
+        blurred = cv2.GaussianBlur(gray, (blur_kernel, blur_kernel), 0)
+
+        # Apply Canny edge detection
+        edges = cv2.Canny(blurred, canny_low, canny_high)
+
+        # Dilate edges to make them thicker if requested
+        if line_thickness > 1:
+            kernel = np.ones((line_thickness, line_thickness), np.uint8)
+            edges = cv2.dilate(edges, kernel, iterations=1)
+
+        # Invert if needed (black on white by default)
+        if not invert:
+            edges = cv2.bitwise_not(edges)
+
+        # Convert to RGB
+        result = cv2.cvtColor(edges, cv2.COLOR_GRAY2RGB)
+
+        return self.to_pil(result)
+
+    def silhouette_stencil(
+        self,
+        image: Union[str, np.ndarray, Image.Image],
+        threshold_method: Literal['otsu', 'adaptive', 'simple'] = 'otsu',
+        threshold_value: int = 127,
+        blur_kernel: int = 5,
+        fill_holes: bool = True,
+        remove_small_objects: int = 500,
+        smooth_edges: bool = True
+    ) -> Image.Image:
+        """
+        Create filled silhouette stencil using thresholding and contours.
+        Perfect for solid stencils, like spray paint templates.
+
+        Args:
+            image: Input image (path, numpy array, or PIL Image)
+            threshold_method: Method for thresholding ('otsu', 'adaptive', 'simple')
+            threshold_value: Threshold value for 'simple' method (0-255)
+            blur_kernel: Gaussian blur kernel size
+            fill_holes: Fill holes in the silhouette
+            remove_small_objects: Remove objects smaller than this (pixels)
+            smooth_edges: Apply morphological smoothing to edges
+
+        Returns:
+            PIL Image with silhouette stencil
+        """
+        # Load image
+        if isinstance(image, str):
+            img = self.load_image(image)
+        elif isinstance(image, Image.Image):
+            img = self.from_pil(image)
+        else:
+            img = image.copy()
+
+        # Convert to grayscale
+        gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
+
+        # Apply Gaussian blur to reduce noise
+        blurred = cv2.GaussianBlur(gray, (blur_kernel, blur_kernel), 0)
+
+        # Apply thresholding based on method
+        if threshold_method == 'otsu':
+            # Otsu's method automatically finds optimal threshold
+            _, binary = cv2.threshold(blurred, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)
+        elif threshold_method == 'adaptive':
+            # Adaptive threshold - good for varying lighting
+            binary = cv2.adaptiveThreshold(
+                blurred, 255, cv2.ADAPTIVE_THRESH_GAUSSIAN_C,
+                cv2.THRESH_BINARY, 11, 2
+            )
+        else:  # simple
+            _, binary = cv2.threshold(blurred, threshold_value, 255, cv2.THRESH_BINARY)
+
+        # Ensure we have black subject on white background
+        # (Check if more white than black, invert if needed)
+        if np.mean(binary) < 127:
+            binary = cv2.bitwise_not(binary)
+
+        # Remove small objects (noise)
+        if remove_small_objects > 0:
+            # Find contours
+            contours, _ = cv2.findContours(
+                cv2.bitwise_not(binary),
+                cv2.RETR_EXTERNAL,
+                cv2.CHAIN_APPROX_SIMPLE
+            )
+
+            # Filter contours by area and redraw
+            mask = np.ones_like(binary) * 255
+            for contour in contours:
+                area = cv2.contourArea(contour)
+                if area >= remove_small_objects:
+                    cv2.drawContours(mask, [contour], -1, 0, -1)
+
+            binary = mask
+
+        # Fill holes in the silhouette
+        if fill_holes:
+            # Find contours
+            contours, hierarchy = cv2.findContours(
+                cv2.bitwise_not(binary),
+                cv2.RETR_CCOMP,
+                cv2.CHAIN_APPROX_SIMPLE
+            )
+
+            # Fill all contours (including holes)
+            mask = np.ones_like(binary) * 255
+            for i, contour in enumerate(contours):
+                # Only draw external contours (fill holes)
+                if hierarchy[0][i][3] == -1:  # External contour
+                    cv2.drawContours(mask, [contour], -1, 0, -1)
+
+            binary = mask
+
+        # Smooth edges using morphological operations
+        if smooth_edges:
+            kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (5, 5))
+            binary = cv2.morphologyEx(binary, cv2.MORPH_CLOSE, kernel)
+            binary = cv2.morphologyEx(binary, cv2.MORPH_OPEN, kernel)
+
+        # Convert to RGB
+        result = cv2.cvtColor(binary, cv2.COLOR_GRAY2RGB)
+
+        return self.to_pil(result)
+
+    def hybrid_stencil(
+        self,
+        image: Union[str, np.ndarray, Image.Image],
+        show_edges: bool = True,
+        show_fill: bool = True,
+        edge_thickness: int = 2
+    ) -> Image.Image:
+        """
+        Create hybrid stencil with both edges and filled regions.
+        Combines edge detection with silhouette for detailed stencils.
+
+        Args:
+            image: Input image (path, numpy array, or PIL Image)
+            show_edges: Include edge lines
+            show_fill: Include filled silhouette
+            edge_thickness: Thickness of edge lines
+
+        Returns:
+            PIL Image with hybrid stencil
+        """
+        # Load image
+        if isinstance(image, str):
+            img = self.load_image(image)
+        elif isinstance(image, Image.Image):
+            img = self.from_pil(image)
+        else:
+            img = image.copy()
+
+        # Start with white canvas
+        result = np.ones_like(cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)) * 255
+
+        # Add filled silhouette if requested
+        if show_fill:
+            silhouette = self.silhouette_stencil(img)
+            silhouette_cv = self.from_pil(silhouette)
+            silhouette_gray = cv2.cvtColor(silhouette_cv, cv2.COLOR_BGR2GRAY)
+            result = cv2.bitwise_and(result, silhouette_gray)
+
+        # Add edges if requested
+        if show_edges:
+            edges = self.edge_stencil(img, line_thickness=edge_thickness, invert=True)
+            edges_cv = self.from_pil(edges)
+            edges_gray = cv2.cvtColor(edges_cv, cv2.COLOR_BGR2GRAY)
+            result = cv2.bitwise_and(result, edges_gray)
+
+        # Convert to RGB
+        result_rgb = cv2.cvtColor(result, cv2.COLOR_GRAY2RGB)
+
+        return self.to_pil(result_rgb)
+
+    def auto_stencil(
+        self,
+        image: Union[str, np.ndarray, Image.Image],
+        style: Literal['outline', 'filled', 'hybrid'] = 'filled'
+    ) -> Image.Image:
+        """
+        Automatically create a stencil with sensible defaults.
+
+        Args:
+            image: Input image (path, numpy array, or PIL Image)
+            style: Style of stencil ('outline', 'filled', 'hybrid')
+
+        Returns:
+            PIL Image with stencil
+        """
+        if style == 'outline':
+            return self.edge_stencil(image)
+        elif style == 'filled':
+            return self.silhouette_stencil(image)
+        else:  # hybrid
+            return self.hybrid_stencil(image)
+
+    def save(self, image: Image.Image, output_path: str):
+        """
+        Save stencil image to file.
+
+        Args:
+            image: PIL Image to save
+            output_path: Path to save image
+        """
+        os.makedirs(os.path.dirname(output_path) or ".", exist_ok=True)
+        image.save(output_path)
+        print(f"Saved stencil to: {output_path}")
+
+
+def main():
+    """Example usage demonstrating different stencil styles."""
+
+    print("StencilCV - Computer Vision Stencil Generator")
+    print("=" * 60)
+
+    # Note: You'll need input images to test this
+    # For now, let's create a simple example
+
+    # Create a sample image (circle)
+    print("\nCreating sample image...")
+    sample = np.ones((512, 512, 3), dtype=np.uint8) * 255
+    cv2.circle(sample, (256, 256), 100, (0, 0, 0), -1)
+    sample_path = "sample_input.png"
+    cv2.imwrite(sample_path, sample)
+    print(f"Created sample image: {sample_path}")
+
+    # Initialize processor
+    processor = StencilCV()
+
+    # Create output directory
+    output_dir = "output_cv_stencils"
+    os.makedirs(output_dir, exist_ok=True)
+
+    # Example 1: Edge/Outline stencil
+    print("\n1. Creating outline stencil...")
+    outline = processor.edge_stencil(sample_path)
+    processor.save(outline, f"{output_dir}/outline_stencil.png")
+
+    # Example 2: Filled silhouette stencil
+    print("2. Creating filled silhouette stencil...")
+    filled = processor.silhouette_stencil(sample_path)
+    processor.save(filled, f"{output_dir}/filled_stencil.png")
+
+    # Example 3: Hybrid stencil
+    print("3. Creating hybrid stencil...")
+    hybrid = processor.hybrid_stencil(sample_path)
+    processor.save(hybrid, f"{output_dir}/hybrid_stencil.png")
+
+    print(f"\n{'=' * 60}")
+    print(f"All stencils saved to: {output_dir}/")
+    print("\nTo use with your own images:")
+    print("  processor = StencilCV()")
+    print("  stencil = processor.auto_stencil('your_image.jpg', style='filled')")
+    print("  processor.save(stencil, 'output.png')")
+
+
+if __name__ == "__main__":
+    main()

app.py

@@ -0,0 +1,389 @@
+"""
+Gradio Web Interface for Stencil Image Generator
+
+This module provides a web-based UI for the Stencil Generator using Gradio.
+Run this file to launch the interactive web interface.
+"""
+
+import gradio as gr
+from Stencil import StencilGenerator
+from StencilCV import StencilCV
+import torch
+from typing import Optional
+import numpy as np
+
+MAX_IMAGES = 4
+
+class StencilApp:
+    """Wrapper class for the Gradio application."""
+
+    def __init__(self):
+        """Initialize the Stencil Generator."""
+        self.generator = None
+        self.original_images = []  # Store original images for toggling
+        self.outlined_status = []  # Track which images have outline applied
+
+    def load_model(self):
+        """Lazy load the model when first needed."""
+        if self.generator is None:
+            print("Initializing Stencil Generator...")
+            self.generator = StencilGenerator(
+                model_id="stabilityai/stable-diffusion-2-1-base",
+                use_fp16=torch.cuda.is_available()
+            )
+        return self.generator
+
+    def generate_stencil(
+        self,
+        prompt: str,
+        negative_prompt: Optional[str],
+        num_images: int,
+        num_inference_steps: int,
+        guidance_scale: float,
+        width: int,
+        height: int,
+        seed: int,
+        use_seed: bool,
+        add_stencil_suffix: bool,
+        clean_background: bool
+    ):
+        """
+        Generate stencil images based on user inputs.
+
+        This is the main function called by the Gradio interface.
+        """
+        if not prompt or prompt.strip() == "":
+            return [], "Please enter a prompt!"
+
+        try:
+            # Load model if not already loaded
+            generator = self.load_model()
+
+            # Generate the image(s)
+            images = generator.generate(
+                prompt=prompt,
+                negative_prompt=negative_prompt if negative_prompt else None,
+                num_images=num_images,
+                num_inference_steps=num_inference_steps,
+                guidance_scale=guidance_scale,
+                width=width,
+                height=height,
+                seed=seed if use_seed else None,
+                add_stencil_suffix=add_stencil_suffix,
+                clean_background=clean_background
+            )
+
+            # Ensure images is a list
+            if not isinstance(images, list):
+                images = [images]
+
+            # Store original images and reset outlined status
+            self.original_images = [img.copy() for img in images]
+            self.outlined_status = [False] * len(images)
+
+            return images, f"Generation successful! Created {len(images)} image(s)."
+
+        except Exception as e:
+            return [], f"Error: {str(e)}"
+
+    def apply_outline(self, gallery_data, selected_index):
+        """
+        Toggle outline processing on a selected image using StencilCV.
+        If the image has outline applied, revert to original. Otherwise, apply outline.
+
+        Args:
+            gallery_data: Gallery data from Gradio (list of images or tuples)
+            selected_index: Index of the selected image (from gr.Gallery select event)
+
+        Returns:
+            Updated gallery and status message
+        """
+        # print(f"DEBUG: apply_outline called")
+        # print(f"DEBUG: gallery_data type: {type(gallery_data)}")
+        # print(f"DEBUG: gallery_data length: {len(gallery_data) if gallery_data else 0}")
+        # print(f"DEBUG: selected_index: {selected_index}")
+
+        if not gallery_data:
+            return gallery_data, "No images to process!"
+
+        if selected_index is None:
+            return gallery_data, "Please select an image first by clicking on it!"
+
+        if selected_index >= len(self.original_images):
+            return gallery_data, "Error: Image index out of range!"
+
+        try:
+            # Create a copy of the gallery data
+            updated_gallery = list(gallery_data)
+
+            # Check if this image already has outline applied
+            if self.outlined_status[selected_index]:
+                # Revert to original
+                # print(f"DEBUG: Reverting image {selected_index} to original")
+                updated_gallery[selected_index] = self.original_images[selected_index].copy()
+                self.outlined_status[selected_index] = False
+                return updated_gallery, f"Reverted image {selected_index + 1} to original."
+            else:
+                # Apply outline
+                # print(f"DEBUG: Applying outline to image {selected_index}")
+
+                # Initialize StencilCV processor
+                processor = StencilCV()
+
+                # Get the original image (not the gallery one, to ensure consistency)
+                original_img = self.original_images[selected_index]
+
+                # print(f"DEBUG: Applying edge_stencil...")
+                # Apply outline to the original image
+                outlined = processor.edge_stencil(original_img)
+                # print(f"DEBUG: Outline applied successfully!")
+
+                # Update gallery with outlined version
+                updated_gallery[selected_index] = outlined
+                self.outlined_status[selected_index] = True
+
+                return updated_gallery, f"Applied outline to image {selected_index + 1}. Click again to revert."
+
+        except Exception as e:
+            import traceback
+            print("DEBUG: Exception occurred:")
+            traceback.print_exc()
+            return gallery_data, f"Error applying outline: {str(e)}"
+
+
+def create_interface():
+    """Create and configure the Gradio interface."""
+
+    app = StencilApp()
+
+    # Define the interface
+    with gr.Blocks(title="Stencil Image Generator", theme=gr.themes.Soft()) as interface:
+
+        gr.Markdown(
+            """
+            # 🎨 Stencil Image Generator
+
+            Generate black and white stencil-style images using AI. Perfect for creating
+            cutting templates, vector art, and silhouette designs.
+            """
+        )
+
+        with gr.Row():
+            with gr.Column(scale=1):
+                # Input controls
+                prompt = gr.Textbox(
+                    label="Prompt",
+                    placeholder="e.g., a cat sitting, a tree with spreading branches...",
+                    lines=3
+                )
+
+                num_images = gr.Slider(
+                    minimum=1,
+                    maximum=MAX_IMAGES,
+                    value=1,
+                    step=1,
+                    label="Number of Images",
+                    info="Generate multiple variations to choose from"
+                )
+
+                with gr.Accordion("Advanced Settings", open=False):
+                    negative_prompt = gr.Textbox(
+                        label="Negative Prompt (optional)",
+                        placeholder="Things to avoid in the generation...",
+                        lines=2
+                    )
+
+                    add_stencil_suffix = gr.Checkbox(
+                        label="Add stencil styling suffix(recommended)",
+                        value=True,
+                        info="Automatically adds stencil-specific styling to your prompt (prompt decorations)"
+                    )
+
+                    clean_background = gr.Checkbox(
+                        label="Clean white background (recommended)",
+                        value=True,
+                        info="Post-process to ensure pure white background and remove artifacts"
+                    )
+
+                    num_inference_steps = gr.Slider(
+                        minimum=10,
+                        maximum=50,
+                        value=25,
+                        step=5,
+                        label="Inference Steps",
+                        info="Higher = better quality but slower"
+                    )
+
+                    guidance_scale = gr.Slider(
+                        minimum=1,
+                        maximum=15,
+                        value=7.5,
+                        step=0.5,
+                        label="Guidance Scale",
+                        info="How closely to follow the prompt (7-8 recommended)"
+                    )
+
+                    with gr.Row():
+                        width = gr.Slider(
+                            minimum=256,
+                            maximum=1024,
+                            value=512,
+                            step=64,
+                            label="Width"
+                        )
+                        height = gr.Slider(
+                            minimum=256,
+                            maximum=1024,
+                            value=512,
+                            step=64,
+                            label="Height"
+                        )
+
+                    with gr.Row():
+                        use_seed = gr.Checkbox(
+                            label="Use fixed seed",
+                            value=False,
+                            info="Enable for reproducible results"
+                        )
+                        seed = gr.Number(
+                            label="Seed",
+                            value=42,
+                            precision=0
+                        )
+
+                generate_btn = gr.Button("Generate Stencil", variant="primary", size="lg")
+
+                # Example prompts
+                gr.Examples(
+                    examples=[
+                        ["a cat sitting"],
+                        ["a tree with spreading branches"],
+                        ["a bicycle"],
+                        ["a coffee cup"],
+                        ["a bird in flight"],
+                        ["a deer with antlers"],
+                        ["a mountain landscape"],
+                        ["a lighthouse by the sea"]
+                    ],
+                    inputs=prompt,
+                    label="Example Prompts"
+                )
+
+            with gr.Column(scale=1):
+                # Output - Gallery for multiple images
+                output_gallery = gr.Gallery(
+                    label="Generated Stencils (click to select)",
+                    show_label=True,
+                    columns=2,
+                    rows=2,
+                    height="auto",
+                    object_fit="contain"
+                )
+                status_text = gr.Textbox(
+                    label="Status",
+                    interactive=False,
+                    lines=1
+                )
+
+                # Hidden state to track selected image
+                selected_image_index = gr.State(value=None)
+
+                # Post-processing section
+                with gr.Accordion("Post-Processing Options", open=False):
+                    gr.Markdown(
+                        """
+                        **Outline Generation**: Click an image above to select it, then click the button below
+                        to toggle outline processing. This creates a line-art effect and works best on images
+                        with clear subjects. Click the button again to revert to the original.
+
+                        You can toggle outline on/off for each image independently to compare styles.
+                        """
+                    )
+                    apply_outline_btn = gr.Button("Toggle Outline on Selected Image", variant="secondary")
+
+                gr.Markdown(
+                    """
+                    ### Tips for Best Results:
+                    - Keep prompts simple and descriptive
+                    - Generate multiple images to see variations
+                    - The AI automatically adds stencil styling
+                    - Use negative prompts to avoid unwanted features
+                    - Try the outline option after generation for different styles
+                    - Higher inference steps = better quality (but slower)
+                    """
+                )
+
+        # Connect the generate button
+        generate_btn.click(
+            fn=app.generate_stencil,
+            inputs=[
+                prompt,
+                negative_prompt,
+                num_images,
+                num_inference_steps,
+                guidance_scale,
+                width,
+                height,
+                seed,
+                use_seed,
+                add_stencil_suffix,
+                clean_background
+            ],
+            outputs=[output_gallery, status_text]
+        )
+
+        # Track when user selects an image in the gallery
+        def update_selection(evt: gr.SelectData):
+            print(f"DEBUG: Gallery selection event - index: {evt.index}")
+            return evt.index
+
+        output_gallery.select(
+            fn=update_selection,
+            outputs=selected_image_index
+        )
+
+        # Connect the outline button
+        apply_outline_btn.click(
+            fn=app.apply_outline,
+            inputs=[output_gallery, selected_image_index],
+            outputs=[output_gallery, status_text]
+        )
+
+        gr.Markdown(
+            """
+            ---
+            Built with [Stable Diffusion](https://stability.ai/) and [Gradio](https://gradio.app/)
+            """
+        )
+
+    return interface
+
+
+def launch(
+    share: bool = False,
+    server_name: str = "0.0.0.0",
+    server_port: int = 7860,
+    **kwargs
+):
+    """
+    Launch the Gradio interface.
+
+    Args:
+        share: Whether to create a public shareable link
+        server_name: Server host (0.0.0.0 for public access)
+        server_port: Port to run the server on
+        **kwargs: Additional arguments passed to gradio.launch()
+    """
+    interface = create_interface()
+    interface.launch(
+        share=share,
+        server_name=server_name,
+        server_port=server_port,
+        **kwargs
+    )
+
+
+if __name__ == "__main__":
+    # Launch with default settings
+    # Set share=True to create a public link
+    launch(share=True, pwa=True)

requirements.txt

@@ -0,0 +1,18 @@
+torch>=2.0.0
+diffusers>=0.21.0
+transformers>=4.30.0
+accelerate>=0.20.0
+safetensors>=0.3.0
+gradio>=4.0.0
+numpy>=1.24.0
+Pillow>=9.0.0
+scipy>=1.10.0
+scikit-image>=0.20.0
+opencv-python>=4.8.0
+
+# Note: Pillow, numpy, scipy, scikit-image required for AI-based post-processing
+# opencv-python required for StencilCV (traditional computer vision approach)
+
+# Tested with:
+# torch==2.4.1, diffusers==0.30.3, transformers==4.44.2
+# accelerate==1.1.1, safetensors==0.4.5, gradio==4.44.0