A!leys Galerie

#!/usr/bin/env python3
"""
PIXEL-MORPH — Intelligenter Batch-Image-Resizer mit Qualitätpräsentationen.

Features:
- 5 intelligente Qualitätpräsentationen (Standard, Portrait, Display, Print, Web)
- Automatische Kontrast-, Schärfe- und Farbverlaufs-Optimierung
- Parallelverarbeitung für schnelle Batch-Verarbeitung
- Progress-Balken für visuelle Rückmeldung
- Support für PNG, JPEG, HEIF, WebP
"""

import os
import sys
import math
import argparse
import concurrent.futures
from typing import List, Tuple, Dict, Optional
from PIL import Image, ImageEnhance, ImageFilter, ImageOps
from tqdm import tqdm
import platform

# Qualitätpräsentationen mit automatischen Parametern
QUALITY_PRESETS = {
    "Standard": {"width": 1920, "height": 1080, "contrast": 1.1, "sharpness": 1.2, "adjust_brightness": 0.1},
    "Portrait": {"width": 1080, "height": 1920, "contrast": 1.05, "sharpness": 1.15, "adjust_brightness": 0.05},
    "Display": {"width": 2560, "height": 1600, "contrast": 1.2, "sharpness": 1.3, "adjust_brightness": 0.05},
    "Print": {"width": 3000, "height": 3000, "contrast": 1.0, "sharpness": 1.1, "adjust_brightness": 0.0},
    "Web": {"width": 1280, "height": 720, "contrast": 1.15, "sharpness": 1.25, "adjust_brightness": 0.05}
}

# Unterstützte Dateitypen
SUPPORTED_EXTENSIONS = {".jpg", ".jpeg", ".png", ".heif", ".webp"}

def adjust_image_quality(image: Image.Image, preset: Dict) -> Image.Image:
    """
    Optimiert ein Bild basierend auf der Qualitätpräsentation.

    Args:
        image: PIL Image Object
        preset: Qualitätpräsentation mit Parametern

    Returns:
        Optimiertes PIL Image Object
    """
    # Automatische Helligkeitsanpassung basierend auf Kontrastpräsentation
    if preset["contrast"] > 1.1:
        adj_brightness = ImageEnhance.Brightness(image).enhance(1 + preset["adjust_brightness"])
    else:
        adj_brightness = image

    # Automatische Schärfeanpassung
    if preset["sharpness"] > 1.2:
        adj_sharpness = ImageEnhance.Sharpness(adj_brightness).enhance(preset["sharpness"])
    else:
        adj_sharpness = adj_brightness

    # Automatischer Kontrast (nur wenn signifikant)
    if preset["contrast"] > 1.05:
        adj_contrast = ImageEnhance.Contrast(adj_sharpness).enhance(preset["contrast"])
    else:
        adj_contrast = adj_sharpness

    return adj_contrast

def resize_image(image_path: str, output_path: str, preset: Dict) -> None:
    """
    Resizt ein Bild und optimiert die Qualität.

    Args:
        image_path: Pfad zur Eingabedatei
        output_path: Pfad zur Ausgabedatei
        preset: Qualitätpräsentation
    """
    try:
        with Image.open(image_path) as img:
            # Automatische Rotationskorrektur
            if img.info.get("orientation"):
                img = ImageOps.exif_transpose(img)

            # Qualität optimieren
            adjusted_img = adjust_image_quality(img, preset)

            # Automatische Skalierung
            img_width, img_height = adjusted_img.size
            target_width, target_height = preset["width"], preset["height"]

            # Berechne Skalierungsfaktor
            width_ratio = target_width / img_width
            height_ratio = target_height / img_height
            scale_factor = min(width_ratio, height_ratio)

            # Resizen mit Anti-Aliasing
            new_size = (int(img_width * scale_factor), int(img_height * scale_factor))
            resized_img = adjusted_img.resize(new_size, Image.LANCZOS)

            # Automatische Qualitätsanpassung basierend auf Dateityp
            if image_path.lower().endswith(".png"):
                resized_img.save(output_path, optimize=True, quality=95)
            elif image_path.lower().endswith(".heif"):
                resized_img.save(output_path, "HEIF", quality=90)
            else:
                resized_img.save(output_path, "JPEG", quality=95)

    except Exception as e:
        print(f"Fehler beim Verarbeiten von {image_path}: {str(e)}")

def process_directory(input_dir: str, output_dir: str, preset_name: str) -> int:
    """
    Verarbeitet ein Verzeichnis mit Bildern.

    Args:
        input_dir: Eingabeverzeichnis
        output_dir: Ausgabeverzeichnis
        preset_name: Name der Qualitätpräsentation

    Returns:
        Anzahl der verarbeiteten Bilder
    """
    if preset_name not in QUALITY_PRESETS:
        print(f"Fehler: Qualitätpräsentation '{preset_name}' nicht gefunden.")
        return 0

    preset = QUALITY_PRESETS[preset_name]
    input_dir = os.path.abspath(input_dir)
    output_dir = os.path.abspath(output_dir)

    if not os.path.exists(input_dir):
        print(f"Fehler: Verzeichnis '{input_dir}' nicht gefunden.")
        return 0

    os.makedirs(output_dir, exist_ok=True)

    # Sammle alle Bilddateien
    image_paths = []
    for root, _, files in os.walk(input_dir):
        for file in files:
            ext = os.path.splitext(file)[1].lower()
            if ext in SUPPORTED_EXTENSIONS:
                image_paths.append(os.path.join(root, file))

    if not image_paths:
        print("Keine unterstützten Bilddateien gefunden.")
        return 0

    # Parallelverarbeitung mit Progress-Balken
    processed_count = 0
    with tqdm(total=len(image_paths), desc=f"Resizen mit {preset_name}") as pbar:
        with concurrent.futures.ThreadPoolExecutor() as executor:
            futures = []
            for image_path in image_paths:
                rel_path = os.path.relpath(image_path, input_dir)
                output_path = os.path.join(output_dir, rel_path)
                os.makedirs(os.path.dirname(output_path), exist_ok=True)
                futures.append(executor.submit(resize_image, image_path, output_path, preset))

            for future in concurrent.futures.as_completed(futures):
                try:
                    future.result()
                    processed_count += 1
                    pbar.update(1)
                except Exception as e:
                    print(f"Fehler beim Verarbeiten: {str(e)}")

    print(f"\nErfolgreich verarbeitet: {processed_count} Bilder")
    return processed_count

def main():
    """
    Haupteinstiegspunkt des Programms.
    """
    parser = argparse.ArgumentParser(description="PIXEL-MORPH — Intelligenter Batch-Image-Resizer")
    parser.add_argument("input_dir", help="Eingabeverzeichnis mit Bildern")
    parser.add_argument("output_dir", help="Ausgabeverzeichnis für resizte Bilder")
    parser.add_argument("--preset", choices=QUALITY_PRESETS.keys(), default="Standard",
                        help="Qualitätpräsentation auswählen (Standard, Portrait, Display, Print, Web)")
    parser.add_argument("--list-presets", action="store_true", help="Zeigt verfügbare Qualitätpräsentationen an")

    args = parser.parse_args()

    if args.list_presets:
        print("Verfügbare Qualitätpräsentationen:")
        for name, preset in QUALITY_PRESETS.items():
            print(f"  {name}: {preset['width']}x{preset['height']} (Contrast: {preset['contrast']}, Sharpness: {preset['sharpness']})")
        return

    process_directory(args.input_dir, args.output_dir, args.preset)

if __name__ == "__main__":
    main()