home / skills / dkyazzentwatwa / chatgpt-skills / image-filter-lab

image-filter-lab skill

/image-filter-lab

This skill applies artistic image filters and custom presets to enhance photos with vintage, sepia, B&W, blur, vignette, and color adjustments.

npx playbooks add skill dkyazzentwatwa/chatgpt-skills --skill image-filter-lab

Review the files below or copy the command above to add this skill to your agents.

Files (3)
SKILL.md
3.6 KB
---
name: image-filter-lab
description: Apply artistic filters to images including vintage, sepia, B&W, blur, sharpen, vignette, and color adjustments. Create custom filter presets.
---

# Image Filter Lab

Apply professional filters and effects to images.

## Features

- **Color Filters**: Sepia, B&W, color tint, saturation
- **Blur Effects**: Gaussian, motion, radial blur
- **Artistic Filters**: Vintage, film grain, vignette
- **Enhancements**: Sharpen, contrast, brightness
- **Custom Presets**: Save and apply filter combinations
- **Batch Processing**: Apply filters to multiple images

## Quick Start

```python
from image_filter import ImageFilterLab

lab = ImageFilterLab()
lab.load("photo.jpg")

# Apply vintage filter
lab.vintage()
lab.save("photo_vintage.jpg")

# Chain multiple effects
lab.load("photo.jpg")
lab.brightness(1.2).contrast(1.1).saturation(0.8).vignette()
lab.save("photo_edited.jpg")
```

## CLI Usage

```bash
# Apply single filter
python image_filter.py --input photo.jpg --filter vintage --output result.jpg

# Apply multiple filters
python image_filter.py -i photo.jpg --sepia --vignette --sharpen -o result.jpg

# Adjust parameters
python image_filter.py -i photo.jpg --brightness 1.2 --contrast 1.1 -o result.jpg

# Batch process
python image_filter.py --batch photos/ --filter vintage --output-dir filtered/
```

## API Reference

### ImageFilterLab Class

```python
class ImageFilterLab:
    def __init__(self)

    # Loading
    def load(self, filepath: str) -> 'ImageFilterLab'

    # Color Filters
    def grayscale(self) -> 'ImageFilterLab'
    def sepia(self, intensity: float = 1.0) -> 'ImageFilterLab'
    def negative(self) -> 'ImageFilterLab'
    def tint(self, color: Tuple, intensity: float = 0.3) -> 'ImageFilterLab'

    # Adjustments
    def brightness(self, factor: float) -> 'ImageFilterLab'
    def contrast(self, factor: float) -> 'ImageFilterLab'
    def saturation(self, factor: float) -> 'ImageFilterLab'
    def hue(self, shift: int) -> 'ImageFilterLab'
    def temperature(self, value: int) -> 'ImageFilterLab'

    # Blur Effects
    def blur(self, radius: int = 5) -> 'ImageFilterLab'
    def motion_blur(self, size: int = 15, angle: int = 0) -> 'ImageFilterLab'
    def radial_blur(self, amount: int = 10) -> 'ImageFilterLab'

    # Sharpen
    def sharpen(self, factor: float = 1.0) -> 'ImageFilterLab'
    def unsharp_mask(self, radius: int = 2, percent: int = 150) -> 'ImageFilterLab'

    # Artistic
    def vintage(self) -> 'ImageFilterLab'
    def film_grain(self, amount: int = 25) -> 'ImageFilterLab'
    def vignette(self, radius: float = 0.8, intensity: float = 0.5) -> 'ImageFilterLab'
    def posterize(self, levels: int = 4) -> 'ImageFilterLab'
    def solarize(self, threshold: int = 128) -> 'ImageFilterLab'

    # Presets
    def apply_preset(self, preset: str) -> 'ImageFilterLab'
    def save_preset(self, name: str, operations: List) -> None

    # Output
    def save(self, filepath: str, quality: int = 95) -> str
    def reset(self) -> 'ImageFilterLab'

    # Batch
    def batch_process(self, input_dir: str, output_dir: str,
                     filter_func: callable) -> List[str]
```

## Built-in Presets

- **vintage**: Sepia tint, reduced saturation, vignette
- **film**: Slight desaturation, grain, crushed blacks
- **instagram**: High contrast, warm tint, vignette
- **noir**: High contrast B&W, strong vignette
- **warm**: Warm color temperature, increased saturation
- **cool**: Cool color temperature, slightly desaturated
- **dramatic**: High contrast, deep shadows
- **dreamy**: Soft blur, bright highlights, low contrast

## Dependencies

- pillow>=10.0.0
- opencv-python>=4.8.0
- numpy>=1.24.0

Overview

This skill provides a compact, Python-first toolkit to apply professional artistic filters and adjustments to images. It offers built-in presets (vintage, film, noir, etc.), individual effects (sepia, blur, sharpen, vignette), and the ability to create and reuse custom presets. It supports single-image edits and batch processing for consistent results across many files.

How this skill works

Load an image into the ImageFilterLab object, chain filter and adjustment methods, then save the result. Methods return the same instance to allow fluent chaining (e.g., brightness().contrast().vignette()). Presets are saved as named operation lists and can be applied programmatically or via the CLI for batch jobs.

When to use it

  • Quickly apply a consistent look across a photo series or social feed.
  • Create custom filter presets for branding or recurring projects.
  • Add artistic touches like film grain, vignette, or vintage tint to portraits.
  • Perform lightweight retouching: sharpen, contrast, brightness, saturation.
  • Batch-process large image folders for catalogs, galleries, or archives.

Best practices

  • Work on copies or export to a different output directory to preserve originals.
  • Chain non-destructive operations and adjust parameter values incrementally.
  • Save frequently used combinations as presets to ensure consistent output.
  • Use batch_process with a filter function that logs failures and returns output paths.
  • Tune sharpening and grain at the end of a chain to avoid exaggerating earlier artifacts.

Example use cases

  • Apply the built-in 'vintage' preset to a wedding photo series and batch-save results.
  • Create a custom 'product_web' preset: subtle sharpen, increased contrast, mild vignette, then apply to all product shots.
  • Quickly convert event photos to high-contrast B&W using the 'noir' preset for a consistent album.
  • Use motion_blur and radial_blur to create dynamic backgrounds for marketing hero images.
  • Generate a set of social media variants by chaining brightness, saturation, and vignette with different parameter values.

FAQ

Which file formats are supported for input and output?

Common formats supported by Pillow and OpenCV work reliably (JPEG, PNG, TIFF). Use save(filepath, quality) to control JPEG quality.

How do I create and reuse a custom preset?

Call save_preset(name, operations) with a list of operations (method names and parameters). Then call apply_preset(name) to reuse it.