Upload 8 files

Dockerfile

@@ -0,0 +1,34 @@
+FROM python:3.11-slim
+
+# Create user for security
+RUN useradd -m -u 1000 user
+USER user
+ENV PATH="/home/user/.local/bin:$PATH"
+
+# Set working directory
+WORKDIR /app
+
+# Install system dependencies
+USER root
+RUN apt-get update && apt-get install -y \
+    libglib2.0-0 \
+    libgomp1 \
+    && rm -rf /var/lib/apt/lists/*
+
+USER user
+
+# Copy requirements and install Python dependencies
+COPY --chown=user ./requirements.txt requirements.txt
+RUN pip install --no-cache-dir --upgrade -r requirements.txt
+
+# Copy application files
+COPY --chown=user . /app
+
+# Create necessary directories
+RUN mkdir -p uploads results
+
+# Expose port (will be set by Hugging Face)
+EXPOSE 7860
+
+# Start application with gunicorn (bind to PORT env var with 7860 fallback)
+CMD ["bash", "-c", "exec gunicorn --workers=2 --threads=4 --timeout=60 --bind=0.0.0.0:${PORT:-7860} app:app"]

README.md

@@ -0,0 +1,57 @@
+---
+title: SketchAI - Image to Sketch Converter
+emoji: 🎨
+colorFrom: purple
+colorTo: pink
+sdk: docker
+app_file: app.py
+pinned: false
+license: mit
+---
+
+# SketchAI - Image to Sketch Converter
+
+Transform your photos into beautiful pencil sketch drawings with AI! SketchAI uses advanced computer vision techniques to convert regular photographs into artistic sketch representations.
+
+## Features
+
+✨ **Beautiful Web Interface** - Stunning dark theme with animated gradient borders  
+🖼️ **Drag & Drop Upload** - Easy image uploading with support for multiple formats  
+⚙️ **Customizable Settings** - Adjust blur intensity and enable enhanced line definition  
+👁️ **Real-time Preview** - See your original and sketch side-by-side  
+💾 **Instant Download** - Get your sketch with one click  
+📱 **Mobile Friendly** - Works perfectly on all devices  
+
+## How It Works
+
+1. **Upload** your image by dragging and dropping or browsing files
+2. **Customize** the sketch settings (blur intensity, enhanced lines)
+3. **Process** - Watch as AI transforms your photo into a sketch
+4. **Download** your beautiful pencil sketch drawing
+
+## Supported Formats
+
+- JPG/JPEG
+- PNG
+- BMP
+- TIFF
+- WebP
+
+## Technical Details
+
+The application uses a multi-step image processing pipeline:
+- **Grayscale Conversion** - Converts color images to grayscale
+- **Image Inversion** - Creates negative for sketch effect
+- **Gaussian Blur** - Applies customizable blur for artistic effect
+- **Color Dodge Blending** - Combines images for realistic pencil sketch appearance
+- **Optional Enhancement** - Adaptive thresholding for sharper lines
+
+Built with Flask, OpenCV, and modern web technologies.
+
+## Usage
+
+Simply visit the app, upload any photo, adjust settings to your liking, and download your personalized sketch artwork!
+
+---
+
+*Created with ❤️ using OpenCV and Flask*

app.py

@@ -0,0 +1,162 @@
+import os
+import uuid
+from flask import Flask, render_template, request, jsonify, send_from_directory, url_for
+from werkzeug.utils import secure_filename
+import cv2
+import numpy as np
+from PIL import Image
+from image_to_sketch import ImageToSketch
+
+app = Flask(__name__)
+
+# Configuration
+app.config['MAX_CONTENT_LENGTH'] = 10 * 1024 * 1024  # 10MB max file size
+app.config['UPLOAD_FOLDER'] = 'uploads'
+app.config['RESULT_FOLDER'] = 'results'
+
+# Allowed file extensions
+ALLOWED_EXTENSIONS = {'png', 'jpg', 'jpeg', 'gif', 'bmp', 'tiff', 'webp'}
+
+def allowed_file(filename):
+    """Check if file extension is allowed."""
+    return '.' in filename and \
+           filename.rsplit('.', 1)[1].lower() in ALLOWED_EXTENSIONS
+
+def ensure_directories():
+    """Ensure upload and result directories exist."""
+    for directory in [app.config['UPLOAD_FOLDER'], app.config['RESULT_FOLDER']]:
+        if not os.path.exists(directory):
+            os.makedirs(directory)
+
+@app.route('/')
+def index():
+    """Serve the main page."""
+    return render_template('index.html')
+
+@app.route('/convert', methods=['POST'])
+def convert_image():
+    """Handle image conversion to sketch."""
+    try:
+        # Check if image was uploaded
+        if 'image' not in request.files:
+            return jsonify({'error': 'No image file provided'}), 400
+        
+        file = request.files['image']
+        if file.filename == '':
+            return jsonify({'error': 'No file selected'}), 400
+        
+        if not allowed_file(file.filename):
+            return jsonify({'error': 'Invalid file type. Please upload an image file.'}), 400
+        
+        # Get processing options
+        blur_value = int(request.form.get('blur', 21))
+        enhance = request.form.get('enhance', 'false').lower() == 'true'
+        
+        # Validate blur value
+        if blur_value < 1:
+            return jsonify({'error': 'Blur value must be positive'}), 400
+        
+        # Make blur value odd
+        if blur_value % 2 == 0:
+            blur_value += 1
+        
+        # Generate unique filename
+        file_id = str(uuid.uuid4())
+        if file.filename and '.' in file.filename:
+            original_ext = file.filename.rsplit('.', 1)[1].lower()
+        else:
+            original_ext = 'jpg'  # Default extension
+        input_filename = f"{file_id}_original.{original_ext}"
+        output_filename = f"{file_id}_sketch.jpg"
+        
+        # Save uploaded file
+        input_path = os.path.join(app.config['UPLOAD_FOLDER'], input_filename)
+        output_path = os.path.join(app.config['RESULT_FOLDER'], output_filename)
+        
+        file.save(input_path)
+        
+        # Convert image to sketch
+        converter = ImageToSketch()
+        sketch = converter.convert_to_sketch(
+            input_path, 
+            output_path, 
+            blur_value=blur_value,
+            enhance=enhance
+        )
+        
+        # Generate URL for the result
+        sketch_url = url_for('get_result', filename=output_filename)
+        
+        # Clean up input file after successful processing
+        try:
+            os.remove(input_path)
+        except Exception:
+            pass  # Don't fail if cleanup fails
+        
+        return jsonify({
+            'success': True,
+            'sketch_url': sketch_url,
+            'blur_value': blur_value,
+            'enhanced': enhance
+        })
+        
+    except cv2.error as e:
+        print(f"OpenCV error processing image: {str(e)}")
+        return jsonify({'error': 'Invalid or corrupted image file'}), 400
+    except Exception as e:
+        print(f"Error processing image: {str(e)}")
+        return jsonify({'error': 'Failed to process image. Please try again.'}), 500
+
+@app.route('/results/<filename>')
+def get_result(filename):
+    """Serve result images."""
+    return send_from_directory(app.config['RESULT_FOLDER'], filename)
+
+# Removed /uploads route for security - originals should not be publicly accessible
+
+@app.errorhandler(413)
+def too_large(e):
+    """Handle file too large error."""
+    return jsonify({'error': 'File size exceeds 10MB limit'}), 413
+
+@app.errorhandler(500)
+def internal_error(e):
+    """Handle internal server errors."""
+    return jsonify({'error': 'Internal server error'}), 500
+
+def cleanup_old_files():
+    """Clean up old uploaded and result files."""
+    import time
+    current_time = time.time()
+    max_age = 24 * 60 * 60  # 24 hours
+    
+    for folder in [app.config['UPLOAD_FOLDER'], app.config['RESULT_FOLDER']]:
+        if os.path.exists(folder):
+            for filename in os.listdir(folder):
+                file_path = os.path.join(folder, filename)
+                if os.path.isfile(file_path):
+                    file_age = current_time - os.path.getctime(file_path)
+                    if file_age > max_age:
+                        try:
+                            os.remove(file_path)
+                            print(f"Cleaned up old file: {file_path}")
+                        except Exception as e:
+                            print(f"Error cleaning up {file_path}: {e}")
+
+if __name__ == '__main__':
+    ensure_directories()
+    
+    # Clean up old files on startup
+    try:
+        cleanup_old_files()
+    except Exception as e:
+        print(f"Error during cleanup: {e}")
+    
+    # Auto-detect port: prefer PORT env var, else 7860 for HF, else 5000 for local
+    port = int(os.environ.get('PORT') or (7860 if 'SPACE_ID' in os.environ else 5000))
+    
+    # Start the Flask development server
+    print("Starting SketchAI Web Application...")
+    print(f"Open your browser and navigate to: http://localhost:{port}")
+    
+    app.run(host='0.0.0.0', port=port, debug=False)

image_to_sketch.py

@@ -0,0 +1,223 @@
+#!/usr/bin/env python3
+"""
+Image to Sketch Converter
+A Python program that converts images to pencil sketch style drawings.
+"""
+
+import cv2
+import numpy as np
+from PIL import Image
+import argparse
+import os
+import sys
+
+
+class ImageToSketch:
+    """Class to handle image to sketch conversion operations."""
+    
+    def __init__(self):
+        # Note: OpenCV supports many formats, so we mainly rely on cv2.imread success
+        self.supported_formats = ['.jpg', '.jpeg', '.png', '.bmp', '.tiff', '.tif', '.webp']
+    
+    def validate_image_file(self, filepath):
+        """Validate if the file exists and has a supported format."""
+        if not os.path.exists(filepath):
+            raise FileNotFoundError(f"Image file not found: {filepath}")
+        
+        file_ext = os.path.splitext(filepath)[1].lower()
+        if file_ext not in self.supported_formats:
+            raise ValueError(f"Unsupported image format: {file_ext}. Supported formats: {', '.join(self.supported_formats)}")
+        
+        return True
+    
+    def load_image(self, filepath):
+        """Load image from file path."""
+        self.validate_image_file(filepath)
+        
+        # Load image using OpenCV
+        image = cv2.imread(filepath)
+        if image is None:
+            raise ValueError(f"Could not load image: {filepath}")
+        
+        return image
+    
+    def convert_to_grayscale(self, image):
+        """Convert color image to grayscale."""
+        return cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
+    
+    def invert_image(self, image):
+        """Invert the grayscale image (create negative)."""
+        return 255 - image
+    
+    def apply_gaussian_blur(self, image, blur_value=21):
+        """Apply Gaussian blur to the image."""
+        # Validate blur value
+        if blur_value < 1:
+            raise ValueError(f"Blur value must be positive (>= 1), got: {blur_value}")
+        if blur_value % 2 == 0:
+            blur_value += 1
+        return cv2.GaussianBlur(image, (blur_value, blur_value), 0)
+    
+    def create_sketch_blend(self, grayscale_img, blurred_img):
+        """Create sketch effect by blending grayscale and blurred images."""
+        # Use color dodge blend mode to create sketch effect
+        sketch = cv2.divide(grayscale_img, 255 - blurred_img, scale=256)
+        return sketch
+    
+    def enhance_sketch(self, sketch):
+        """Enhance the sketch with additional processing."""
+        # Apply adaptive threshold for better line definition
+        enhanced = cv2.adaptiveThreshold(
+            sketch, 255, cv2.ADAPTIVE_THRESH_MEAN_C, cv2.THRESH_BINARY, 9, 9
+        )
+        return enhanced
+    
+    def convert_to_sketch(self, input_path, output_path=None, blur_value=21, enhance=False):
+        """
+        Main method to convert image to sketch.
+        
+        Args:
+            input_path (str): Path to input image
+            output_path (str): Path to save sketch (optional)
+            blur_value (int): Gaussian blur intensity (default: 21)
+            enhance (bool): Apply enhancement for better line definition
+        
+        Returns:
+            numpy.ndarray: Sketch image array
+        """
+        print(f"Loading image: {input_path}")
+        
+        # Load the original image
+        original_image = self.load_image(input_path)
+        
+        # Convert to grayscale
+        print("Converting to grayscale...")
+        grayscale = self.convert_to_grayscale(original_image)
+        
+        # Invert the grayscale image
+        print("Creating inverted image...")
+        inverted = self.invert_image(grayscale)
+        
+        # Apply Gaussian blur to inverted image
+        print(f"Applying Gaussian blur (blur value: {blur_value})...")
+        blurred = self.apply_gaussian_blur(inverted, blur_value)
+        
+        # Create sketch by blending
+        print("Creating sketch blend...")
+        sketch = self.create_sketch_blend(grayscale, blurred)
+        
+        # Apply enhancement if requested
+        if enhance:
+            print("Enhancing sketch...")
+            sketch = self.enhance_sketch(sketch)
+        
+        # Save the sketch if output path is provided
+        if output_path:
+            self.save_sketch(sketch, output_path)
+            print(f"Sketch saved to: {output_path}")
+        
+        return sketch
+    
+    def save_sketch(self, sketch, output_path):
+        """Save sketch image to file."""
+        # Ensure output directory exists
+        output_dir = os.path.dirname(output_path)
+        if output_dir and not os.path.exists(output_dir):
+            os.makedirs(output_dir)
+        
+        # Save using OpenCV
+        success = cv2.imwrite(output_path, sketch)
+        if not success:
+            raise ValueError(f"Failed to save sketch to: {output_path}")
+    
+    def display_comparison(self, original_path, sketch):
+        """Display original and sketch side by side using matplotlib."""
+        try:
+            import matplotlib.pyplot as plt
+            
+            # Load original for comparison
+            original = self.load_image(original_path)
+            original_rgb = cv2.cvtColor(original, cv2.COLOR_BGR2RGB)
+            
+            # Create side-by-side comparison
+            fig, axes = plt.subplots(1, 2, figsize=(12, 6))
+            
+            axes[0].imshow(original_rgb)
+            axes[0].set_title('Original Image')
+            axes[0].axis('off')
+            
+            axes[1].imshow(sketch, cmap='gray')
+            axes[1].set_title('Sketch')
+            axes[1].axis('off')
+            
+            plt.tight_layout()
+            plt.show()
+            
+        except ImportError:
+            print("Matplotlib not available for display. Sketch conversion completed successfully.")
+
+
+def main():
+    """Main function to handle command line interface."""
+    parser = argparse.ArgumentParser(
+        description="Convert images to pencil sketch style drawings",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+  python image_to_sketch.py input.jpg
+  python image_to_sketch.py input.jpg -o sketch.png
+  python image_to_sketch.py input.jpg -o sketch.png --blur 25 --enhance
+  python image_to_sketch.py input.jpg --display
+        """
+    )
+    
+    parser.add_argument('input', help='Input image file path')
+    parser.add_argument('-o', '--output', help='Output sketch file path')
+    parser.add_argument('--blur', type=int, default=21, 
+                       help='Gaussian blur value (default: 21, must be odd)')
+    parser.add_argument('--enhance', action='store_true',
+                       help='Apply enhancement for better line definition')
+    parser.add_argument('--display', action='store_true',
+                       help='Display original and sketch comparison')
+    
+    args = parser.parse_args()
+    
+    # Validate blur value (must be positive and odd)
+    if args.blur < 1:
+        print(f"Error: Blur value must be positive (>= 1), got: {args.blur}", file=sys.stderr)
+        sys.exit(1)
+    if args.blur % 2 == 0:
+        args.blur += 1
+        print(f"Blur value adjusted to {args.blur} (must be odd)")
+    
+    # Generate output filename if not provided
+    if not args.output:
+        input_name, input_ext = os.path.splitext(args.input)
+        args.output = f"{input_name}_sketch{input_ext}"
+    
+    try:
+        # Create converter instance
+        converter = ImageToSketch()
+        
+        # Convert image to sketch
+        sketch = converter.convert_to_sketch(
+            args.input, 
+            args.output, 
+            blur_value=args.blur,
+            enhance=args.enhance
+        )
+        
+        print(f"\n✓ Successfully converted '{args.input}' to sketch!")
+        print(f"✓ Sketch saved as: '{args.output}'")
+        
+        # Display comparison if requested
+        if args.display:
+            converter.display_comparison(args.input, sketch)
+            
+    except Exception as e:
+        print(f"Error: {e}", file=sys.stderr)
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

pyproject.toml

@@ -0,0 +1,12 @@
+[project]
+name = "repl-nix-workspace"
+version = "0.1.0"
+description = "Add your description here"
+requires-python = ">=3.11"
+dependencies = [
+    "flask>=3.1.2",
+    "matplotlib>=3.10.6",
+    "numpy>=2.3.3",
+    "opencv-python>=4.11.0.86",
+    "pillow>=11.3.0",
+]

replit.md

@@ -0,0 +1,64 @@
+# Image to Sketch Converter
+
+## Overview
+
+This is a Python-based image processing application that converts regular photographs and images into pencil sketch style drawings. The application uses computer vision techniques to transform color images into artistic sketch representations, providing a simple command-line interface for image conversion operations.
+
+## Recent Changes
+
+### September 29, 2025
+- Created complete image-to-sketch conversion program (`image_to_sketch.py`)
+- Implemented core algorithms: grayscale conversion, image inversion, Gaussian blur, and color-dodge blending
+- Added comprehensive command-line interface with help system
+- Included optional sketch enhancement with adaptive thresholding
+- **NEW: Built beautiful web interface with Flask backend**
+  - Adapted stunning dark theme design for sketch conversion
+  - Drag & drop file upload with animated gradient borders
+  - Real-time image processing with visual feedback
+  - Side-by-side original vs sketch comparison
+  - Adjustable settings (blur intensity, enhanced lines)
+  - Secure file handling and automatic cleanup
+- Successfully tested complete web application and verified output quality
+- Configured workflow for easy web server deployment
+
+## User Preferences
+
+Preferred communication style: Simple, everyday language.
+
+## System Architecture
+
+### Core Processing Architecture
+- **Object-oriented design**: Built around the `ImageToSketch` class that encapsulates all conversion logic and image processing operations
+- **Pipeline-based processing**: Uses a multi-step conversion process including grayscale conversion and image inversion as the foundation for sketch creation
+- **File validation system**: Implements robust input validation to ensure image files exist and are in supported formats before processing
+
+### Image Processing Framework
+- **OpenCV integration**: Primary image processing library for loading, manipulating, and converting images with support for multiple image formats
+- **PIL/Pillow support**: Secondary image handling capability for additional format compatibility and image operations
+- **NumPy arrays**: Underlying data structure for efficient image pixel manipulation and mathematical operations
+
+### Input/Output Handling
+- **Multi-format support**: Handles common image formats including JPG, PNG, BMP, TIFF, and WebP files
+- **Command-line interface**: Uses argparse for parsing command-line arguments and user input processing
+- **Error handling**: Comprehensive validation for file existence, format compatibility, and image loading failures
+
+### Processing Pipeline
+- **Grayscale conversion**: First step converts color images to grayscale using OpenCV's color space transformation
+- **Image inversion**: Creates negative images by inverting pixel values (255 - pixel_value) as part of the sketch effect
+- **Extensible design**: Architecture allows for easy addition of additional processing steps in the conversion pipeline
+
+## External Dependencies
+
+### Core Libraries
+- **OpenCV (cv2)**: Primary computer vision library for image loading, processing, and format handling
+- **NumPy**: Numerical computing library for efficient array operations and pixel manipulation
+- **PIL/Pillow**: Python Imaging Library for additional image processing capabilities and format support
+
+### System Dependencies
+- **Python 3**: Requires Python 3.x runtime environment
+- **argparse**: Built-in Python module for command-line argument parsing
+- **os and sys**: Standard library modules for file system operations and system interaction
+
+### File System Requirements
+- **Input validation**: Depends on local file system for image file validation and loading
+- **Format detection**: Uses file extensions and OpenCV's built-in format detection for image compatibility

requirements.txt

@@ -0,0 +1,5 @@
+flask==3.1.2
+opencv-python-headless==4.11.0.86
+numpy==2.3.3
+pillow==11.3.0
+gunicorn==23.0.0