Image Color Palette Extractor (python, written by Gemini Code Assist)

Gemini Code Assist wrote this python project from the task below. It does not run on a clean Ubuntu 22.04 machine as written.

Task given to the agent:

TASK: Image Color Palette Extractor

Write a program that extracts the dominant color palette from images using color quantization algorithms, outputting the palette in multiple formats with percentage breakdowns.

FUNCTIONAL REQUIREMENTS:
- Accept an image file path as a command-line argument
- Extract a configurable number of dominant colors via --colors flag (default: 8, range 2-32)
- Use k-means clustering or median cut algorithm for color quantization (selectable via --algorithm flag)
- Output each color in multiple formats: hex (#RRGGBB), RGB (r,g,b), and HSL (h,s%,l%)
- Report the percentage of the image each dominant color represents
- Support color name mapping: find the closest named CSS/HTML color for each extracted color
- Generate a color palette visualization as a PNG image showing color swatches with hex labels via --visual flag
- Support extracting palette from a specific region of the image via --crop flag (x,y,width,height)
- Support color space analysis: report if the image is primarily warm-toned, cool-toned, or neutral based on the palette hue distribution
- Compare palettes between two images via --compare flag, showing common colors and unique colors with delta-E color difference scores
- Print the palette to console as a formatted table with color swatches represented by ANSI colored blocks
- Save the palette data as JSON with --output flag (default: palette.json)
- Support batch extraction from a directory of images via --batch flag with a summary showing all palettes
- If no input is given, generate three sample images (a sunset scene using warm gradients, an ocean scene using cool gradients, a forest scene using green tones), extract palettes from each, and display comparative results
- Handle errors: unsupported formats, very small images, images with very few unique colors

Create a complete Python project for a clean Ubuntu 22.04 machine with only Python 3.10+ installed. Include:
- Source code
- requirements.txt with all dependencies (direct and transitive) pinned to exact versions
- README.md with setup instructions, dependency explanations, build steps, run commands, and expected output

[]

import sys
import argparse
import os
import json
import numpy as np
from PIL import Image
from sklearn.cluster import KMeans

def extract_palette(image_path, n_colors=8):
    if not os.path.exists(image_path):
        print(f"Error: {image_path} not found.")
        return []

    try:
        with Image.open(image_path) as img:
            img = img.convert('RGB')
            # Resize image to speed up k-means
            img = img.resize((150, 150))
            data = np.array(img).reshape(-1, 3)
            
        # Perform K-Means clustering to find dominant colors
        kmeans = KMeans(n_clusters=n_colors, n_init='auto', random_state=42)
        kmeans.fit(data)
        
        colors = kmeans.cluster_centers_.astype(int)
        labels = kmeans.labels_
        counts = np.bincount(labels)
        total = len(labels)
        
        palette = []
        for i in range(len(colors)):
            rgb = colors[i]
            hex_val = '#{:02x}{:02x}{:02x}'.format(*rgb)
            palette.append({
                "rgb": rgb.tolist(),
                "hex": hex_val,
                "percentage": round((counts[i] / total) * 100, 2)
            })
            
        # Sort by dominance
        palette.sort(key=lambda x: x['percentage'], reverse=True)
        return palette
    except Exception as e:
        print(f"Error extracting palette: {e}")
        return []

def main():
    parser = argparse.ArgumentParser(description="Image Color Palette Extractor")
    parser.add_argument("input", nargs="?", help="Input image path")
    parser.add_argument("--colors", type=int, default=8, help="Number of colors to extract")
    parser.add_argument("--output", default="palette.json", help="Output JSON file")
    
    args = parser.parse_args()
    
    target = args.input
    if not target:
        print("Demo: Creating a sample image...")
        # Create a sample multi-colored image
        data = np.zeros((100, 100, 3), dtype=np.uint8)
        data[:50, :50] = [255, 0, 0]    # Red
        data[:50, 50:] = [0, 255, 0]    # Green
        data[50:, :50] = [0, 0, 255]    # Blue
        data[50:, 50:] = [255, 255, 0]  # Yellow
        img = Image.fromarray(data)
        img.save("sample_palette.png")
        target = "sample_palette.png"
        
    results = extract_palette(target, args.colors)
    
    if results:
        print(f"
--- Dominant Colors for {target} ---")
        for c in results:
            print(f"{c['hex']} | {c['percentage']:>5}% | RGB: {c['rgb']}")
            
        with open(args.output, 'w') as f:
            json.dump(results, f, indent=4)
        print(f"
Full palette saved to {args.output}")

if __name__ == "__main__":
    main()

# Image Color Palette Extractor (Python)

A tool for extracting dominant colors from images using K-Means clustering.

## Setup Instructions

1. Ensure Python 3.10+ is installed.
2. Create a virtual environment:
   ```bash
   python3 -m venv venv
   source venv/bin/activate
   ```
3. Install dependencies:
   ```bash
   pip install -r requirements.txt
   ```

## Run Commands

- **Extract Palette**:
  ```bash
  python palette_extractor.py photo.jpg --colors 5
  ```
- **Run Demo**:
  ```bash
  python palette_extractor.py
  ```

## Features
- **Color Quantization**: Uses K-Means to identify dominant color clusters.
- **Detailed Output**: Provides HEX, RGB, and percentage breakdown.
- **JSON Export**: Saves results to a structured file for programmatic use.

Pillow==10.2.0
scikit-learn==1.4.1.post1
numpy==1.26.4