🎯 Overview

Cartoonify Images OpenCV is a sophisticated computer vision application that transforms ordinary photographs into captivating cartoon-style artwork. Built with OpenCV, NumPy, and enhanced with a user-friendly Gradio web interface, this project demonstrates the power of image processing techniques including edge detection, color quantization, and bilateral filtering.

🎭 What Makes This Special?

• 🎨 Advanced Image Processing: Utilizes cutting-edge OpenCV algorithms for professional-quality results
• 🌐 Web-Based Interface: No installation required for end-users - just upload and cartoonify!
• ⚡ Real-Time Processing: Fast and efficient image transformation
• 🔧 Customizable Parameters: Fine-tune the cartoonification process
• 📱 Cross-Platform: Works on Windows, macOS, and Linux
• 🎓 Educational: Perfect for learning computer vision concepts

✨ Features

🎨 Core Features

• 🖼️ Image Cartoonification: Transform any image into cartoon-style artwork
• 🎭 Edge Detection: Advanced adaptive thresholding for clean edge lines
• 🌈 Color Quantization: K-means clustering for cartoon-like color reduction
• ✨ Bilateral Filtering: Noise reduction while preserving edges
• ⚙️ Customizable Parameters: Adjust line thickness, blur values, and color clusters

🌐 Web Interface Features

• 📤 Drag & Drop Upload: Easy image uploading
• 👀 Real-Time Preview: Instant results display
• 💾 Download Results: Save your cartoonified images
• 📱 Responsive Design: Works on desktop and mobile devices
• 🎯 User-Friendly: No technical knowledge required

🔧 Developer Features

• 📦 Modular Architecture: Clean, maintainable code structure
• 🧪 Jupyter Notebook: Exploration and experimentation environment
• 📚 Comprehensive Documentation: Detailed guides and examples
• 🎛️ Configurable Settings: Easy parameter adjustment
• 🔍 Debug Mode: Development and testing capabilities

🎪 Live Demo

🌐 Web Interface

Launch the Gradio web application to try cartoonifying your images instantly:

python app/main.py

Then open your browser and navigate to http://localhost:7860

📱 Features You'll Love:

• Upload: Drag and drop or click to upload your image
• Process: Watch as your image transforms in real-time
• Download: Save your cartoon masterpiece
• Experiment: Try different images and see amazing results!

🛠️ Installation

📋 Prerequisites

• Python 3.7+ (Python 3.8+ recommended)
• pip package manager
• Git (for cloning the repository)

🔧 Step-by-Step Installation

1. Clone the Repository

   git clone https://github.com/NhanPhamThanh-IT/Cartoonify-Images-OpenCV.git
   cd Cartoonify-Images-OpenCV
   

2. Create Virtual Environment (Recommended)

   # Windows
   python -m venv cartoonify_env
   cartoonify_env\Scripts\activate
   
   # macOS/Linux
   python3 -m venv cartoonify_env
   source cartoonify_env/bin/activate
   

3. Install Dependencies

   pip install -r requirements.txt
   

4. Verify Installation

   python -c "import cv2, numpy, gradio; print('All dependencies installed successfully!')"
   

📦 Dependencies

🚀 Quick Start

🎮 Method 1: Web Interface (Recommended for Beginners)

# Navigate to the project directory
cd Cartoonify-Images-OpenCV

# Launch the web application
python app/main.py

Open your browser and go to http://localhost:7860 to start cartoonifying images!

💻 Method 2: Python Script (For Developers)

from app.core.Cartoonizer import Cartoonizer
import cv2

# Initialize the cartoonizer
cartoonizer = Cartoonizer()

# Load and process an image
image = cv2.imread('path/to/your/image.jpg')
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Cartoonify the image
cartoon_image = cartoonizer.cartoonify(image_rgb)

# Save the result
cv2.imwrite('cartoonified_image.jpg', cv2.cvtColor(cartoon_image, cv2.COLOR_RGB2BGR))

🔬 Method 3: Jupyter Notebook (For Exploration)

# Navigate to exploration directory
cd exploration

# Launch Jupyter Notebook
jupyter notebook notebook.ipynb

📁 Project Structure

Cartoonify-Images-OpenCV/
│
├── 📄 README.md                    # Comprehensive project documentation
├── 📄 LICENSE                      # MIT License
├── 📄 requirements.txt             # Python dependencies
│
├── 📁 app/                         # Main application directory
│   ├── 📄 main.py                  # Gradio web interface entry point
│   │
│   ├── 📁 config/                  # Configuration management
│   │   ├── 📄 __init__.py         # Package initialization
│   │   └── 📄 AppVariables.py     # Application constants and settings
│   │
│   └── 📁 core/                    # Core processing logic
│       ├── 📄 __init__.py         # Package initialization
│       └── 📄 Cartoonizer.py      # Main cartoonification algorithms
│
├── 📁 docs/                        # Documentation and guides
│   ├── 📄 gradio.md               # Gradio framework guide
│   ├── 📄 matplotlib-pyplot.md   # Matplotlib visualization guide
│   └── 📄 opencv.md              # OpenCV techniques documentation
│
└── 📁 exploration/                 # Research and experimentation
    ├── 📄 notebook.ipynb          # Jupyter notebook for exploration
    └── 📁 images/                  # Sample images for testing
        └── 📄 image.jpg           # Test image

🎨 How It Works

The cartoonification process involves several sophisticated computer vision techniques:

🔍 1. Edge Detection

def edge_mask(self, img):
    gray = cv2.cvtColor(img, cv2.COLOR_RGB2GRAY)
    gray_blur = cv2.medianBlur(gray, self.blur_value)
    edges = cv2.adaptiveThreshold(
        gray_blur, 255, cv2.ADAPTIVE_THRESH_MEAN_C,
        cv2.THRESH_BINARY, self.line_size, self.blur_value
    )
    return edges

• Grayscale Conversion: Convert to single channel for edge detection
• Median Blur: Noise reduction while preserving edges
• Adaptive Thresholding: Dynamic threshold calculation for optimal edge detection

🌈 2. Color Quantization

def color_quantization(self, img):
    data = np.float32(img).reshape((-1, 3))
    criteria = (cv2.TERM_CRITERIA_EPS + cv2.TERM_CRITERIA_MAX_ITER, 20, 0.001)
    _, label, center = cv2.kmeans(
        data, self.k, None, criteria, 10, cv2.KMEANS_RANDOM_CENTERS
    )
    return result.reshape(img.shape)

• K-Means Clustering: Groups similar colors together
• Color Reduction: Reduces color palette for cartoon effect
• Cluster Centers: Representative colors for each group

✨ 3. Bilateral Filtering

def apply_bilateral_filter(self, img):
    return cv2.bilateralFilter(img, d=7, sigmaColor=200, sigmaSpace=200)

• Edge Preservation: Maintains sharp edges while smoothing
• Noise Reduction: Removes unwanted artifacts
• Cartoon Smoothness: Creates the smooth appearance typical of cartoons

🎭 4. Final Combination

The final cartoon effect is achieved by combining the edge mask with the processed image:

cartoon = cv2.bitwise_and(blurred, blurred, mask=edges)

🔧 Configuration

⚙️ Cartoonizer Parameters

You can customize the cartoonification process by adjusting these parameters:

🎛️ Customization Example

# Create a custom cartoonizer with specific parameters
custom_cartoonizer = Cartoonizer(
    line_size=5,      # Thinner lines
    blur_value=9,     # More blur
    k=12             # More color variety
)

# Apply custom cartoonification
result = custom_cartoonizer.cartoonify(your_image)

🎨 App Variables

Modify app/config/AppVariables.py to customize the web interface:

class AppVariables:
    TITLE = "Your Custom Cartoonify App"
    DESCRIPTION = "<center>Transform your photos into amazing cartoons!</center>"

    # Additional customizable parameters
    MAX_IMAGE_SIZE = (1920, 1080)
    SUPPORTED_FORMATS = ['jpg', 'jpeg', 'png', 'bmp']
    DEFAULT_LINE_SIZE = 7
    DEFAULT_BLUR_VALUE = 7
    DEFAULT_K_VALUE = 9

📊 Exploration & Examples

🔬 Jupyter Notebook Features

The exploration/notebook.ipynb provides:

• 📈 Step-by-Step Visualization: See each processing stage
• 🎛️ Interactive Parameter Tuning: Experiment with different settings
• 📊 Before/After Comparisons: Visual results analysis
• 🔍 Algorithm Deep Dive: Understand the underlying techniques
• 🎨 Multiple Example Images: Test with various image types

🖼️ Example Results

📋 Exploration Topics

1. Edge Detection Comparison: Different thresholding methods
2. Color Quantization Effects: Various K-values impact
3. Bilateral Filter Parameters: Smoothing vs edge preservation
4. Combined Techniques: How all methods work together
5. Performance Analysis: Processing time vs quality trade-offs

🎯 Use Cases

🎨 Creative Applications

• Digital Art Creation: Transform photos into artwork
• Social Media Content: Eye-catching profile pictures and posts
• Marketing Materials: Unique visual content for campaigns
• Greeting Cards: Personalized cartoon-style cards