A!leys Galerie

#!/usr/bin/env python3
"""Ailey's Glitch Art Generator - Turns images into psychedelic digital noise art."""

import os
import sys
import random
from typing import Tuple, Optional, List
from pathlib import Path
from PIL import Image, ImageFilter, ImageDraw, ImageOps

class GlitchArtGenerator:
    """Core class for generating glitch art from input images."""

    def __init__(self, seed: Optional[int] = None):
        """Initialize the generator with optional random seed."""
        if seed is not None:
            random.seed(seed)
        self._effects = [
            self._apply_pixel_glitch,
            self._apply_color_swap,
            self._apply_QR_distortion,
            self._apply_geometric_shift,
            self._apply_scanshift,
            self._apply_vertical_lines,
            self._apply_horizontal_lines,
            self._apply_chroma_shift,
            self._apply_blue_screen,
            self._apply_interlace
        ]

    def process_image(self, input_path: str, output_path: str, intensity: float = 0.7) -> None:
        """
        Process an image through the glitch art pipeline.

        Args:
            input_path: Path to input image
            output_path: Path to save output
            intensity: Controls how extreme the glitches are (0.0-1.0)
        """
        if not os.path.exists(input_path):
            raise FileNotFoundError(f"Input image not found: {input_path}")

        try:
            with Image.open(input_path) as img:
                glitched = img.copy()
                effects = random.sample(self._effects, k=random.randint(2, 5))

                for effect in effects:
                    if random.random() < intensity:
                        glitched = effect(glitched)

                glitched.save(output_path)
                print(f"✨ Glitch art saved to: {output_path}")
        except Exception as e:
            print(f"❌ Error processing image: {str(e)}", file=sys.stderr)
            raise

    def _apply_pixel_glitch(self, img: Image.Image) -> Image.Image:
        """Randomly corrupt pixels to create digital noise."""
        width, height = img.size
        draw = ImageDraw.Draw(img)
        pixels = img.load()

        for x in range(width):
            for y in range(height):
                if random.random() > 0.8:  # 20% chance of corruption
                    r = random.randint(0, 255)
                    g = random.randint(0, 255)
                    b = random.randint(0, 255)
                    pixels[x, y] = (r, g, b)
        return img

    def _apply_color_swap(self, img: Image.Image) -> Image.Image:
        """Swap RGB channels for a color shift effect."""
        pixels = img.load()
        width, height = img.size

        for x in range(width):
            for y in range(height):
                r, g, b = pixels[x, y][:3]
                if random.random() > 0.7:  # 30% chance of swap
                    pixels[x, y] = (b, r, g)
        return img

    def _apply_QR_distortion(self, img: Image.Image) -> Image.Image:
        """Simulate QR code distortion effect."""
        if random.random() > 0.3:  # 70% chance to skip
            return img

        # Create QR-like pattern overlay
        overlay = Image.new('RGB', img.size, (255, 255, 255))
        draw = ImageDraw.Draw(overlay)

        grid_size = max(1, img.width // 10)
        for x in range(0, img.width, grid_size):
            for y in range(0, img.height, grid_size):
                if random.random() > 0.5:
                    draw.rectangle([x, y, x + grid_size, y + grid_size], fill=(0, 0, 0))

        # Combine with original
        img = Image.alpha_composite(img.convert('RGBA'), overlay.convert('RGBA'))
        return img

    def _apply_geometric_shift(self, img: Image.Image) -> Image.Image:
        """Shift image pixels in random geometric patterns."""
        width, height = img.size
        draw = ImageDraw.Draw(img)

        # Random shift amount
        shift_x = random.randint(-20, 20)
        shift_y = random.randint(-20, 20)

        # Create shifted version
        shifted = img.transform(
            (width, height),
            Image.AFFINE,
            (1, 0, shift_x, 0, 1, shift_y),
            fillcolor=(0, 0, 0)
        )

        # Blend with original
        alpha = Image.new('L', img.size, 128)
        result = Image.composite(img, shifted, alpha)
        return result

    def _apply_scanshift(self, img: Image.Image) -> Image.Image:
        """Simulate old CRT television scan lines."""
        scan_lines = Image.new('L', img.size, 0)
        draw = ImageDraw.Draw(scan_lines)

        for y in range(0, img.height, 3):
            draw.line([(0, y), (img.width, y)], fill=255, width=1)

        # Apply to image
        img = Image.composite(img, scan_lines.convert('RGB'), scan_lines)
        return img

    def _apply_vertical_lines(self, img: Image.Image) -> Image.Image:
        """Add vertical glitch lines."""
        width, height = img.size
        draw = ImageDraw.Draw(img)

        for x in range(0, width, random.randint(10, 30)):
            if random.random() > 0.5:
                draw.line([(x, 0), (x, height)], fill=(random.randint(100, 255), 0, 0), width=1)

        return img

    def _apply_horizontal_lines(self, img: Image.Image) -> Image.Image:
        """Add horizontal glitch lines."""
        width, height = img.size
        draw = ImageDraw.Draw(img)

        for y in range(0, height, random.randint(10, 30)):
            if random.random() > 0.5:
                draw.line([(0, y), (width, y)], fill=(0, 0, random.randint(100, 255)), width=1)

        return img

    def _apply_chroma_shift(self, img: Image.Image) -> Image.Image:
        """Shift hue values to create psychedelic effect."""
        pixels = img.load()
        width, height = img.size

        for x in range(width):
            for y in range(height):
                r, g, b = pixels[x, y]
                if random.random() > 0.7:
                    # Random hue shift
                    shift = random.randint(-50, 50)
                    r = max(0, min(255, r + shift))
                    g = max(0, min(255, g + shift))
                    b = max(0, min(255, b + shift))
                    pixels[x, y] = (r, g, b)
        return img

    def _apply_blue_screen(self, img: Image.Image) -> Image.Image:
        """Apply blue screen chroma key effect."""
        # Create blue screen pattern
        blue_screen = Image.new('RGB', img.size, (50, 100, 255))
        draw = ImageDraw.Draw(blue_screen)

        # Add some distortion
        for x in range(0, img.width, 20):
            for y in range(0, img.height, 20):
                if random.random() > 0.5:
                    draw.rectangle([x, y, x + 20, y + 20], fill=(0, 0, 255))

        # Blend with original
        alpha = Image.new('L', img.size, 128)
        result = Image.composite(blue_screen, img, alpha)
        return result

    def _apply_interlace(self, img: Image.Image) -> Image.Image:
        """Simulate interlaced video effect."""
        width, height = img.size
        interlaced = Image.new('RGB', (width, height))

        for y in range(height):
            for x in range(width):
                if y % 2 == 0:  # Even lines
                    interlaced.putpixel((x, y), img.getpixel((x, y//2 * 2)))
                else:  # Odd lines (shifted)
                    interlaced.putpixel((x, y), img.getpixel((x, (y+1)//2 * 2)))

        return interlaced

def main():
    """Command-line interface for the Glitch Art Generator."""
    import argparse

    parser = argparse.ArgumentParser(
        description="Ailey's Glitch Art Generator - Create psychedelic digital noise art from images."
    )
    parser.add_argument('input', help='Input image path')
    parser.add_argument('output', help='Output image path')
    parser.add_argument('--intensity', type=float, default=0.7,
                        help='Glitch intensity (0.0-1.0, default: 0.7)')
    parser.add_argument('--seed', type=int, default=None,
                        help='Random seed for reproducible results')

    args = parser.parse_args()

    try:
        generator = GlitchArtGenerator(seed=args.seed)
        generator.process_image(args.input, args.output, intensity=args.intensity)
    except Exception as e:
        print(f"❌ Error: {str(e)}", file=sys.stderr)
        sys.exit(1)

if __name__ == "__main__":
    main()