Effiziente PNG-Optimierung in Python mit Oxipng

# Check Python version (3.8+ recommended)
python --version

# Install pyoxipng and optional dependencies
pip install pyoxipng pillow numpy

import oxipng

try:
    # Optimize 'input.png' and save it as 'output.png'
    # Level ranges from 0 (fastest, least compression) to 6 (slowest, best compression). Default is 2.
    oxipng.optimize('input.png', 'output.png', level=4)
    print("Optimization successful!")
except oxipng.PngError as e:
    print(f"Error optimizing PNG: {e}")
except FileNotFoundError:
    print("Error: Input file not found.")

import oxipng
import os
from concurrent.futures import ThreadPoolExecutor
from pathlib import Path

# Define source and destination directories
SRC_DIR = Path('images_source')
DST_DIR = Path('images_optimized')
DST_DIR.mkdir(exist_ok=True) # Create destination if it doesn't exist

# Find all PNG files in the source directory
png_files = list(SRC_DIR.glob('*.png'))

# Function to optimize a single PNG file
def optimize_png(source_path: Path) -> None:
    dest_path = DST_DIR / source_path.name
    try:
        oxipng.optimize(source_path, dest_path, level=4)
        print(f'✓ Optimized: {source_path.name}')
    except oxipng.PngError as e:
        print(f'✗ Failed: {source_path.name} - {e}')
    except Exception as e:
        print(f'✗ Error processing {source_path.name}: {e}')

# Use a threadpoolexecutor for parallel processing
# Adjust max_workers based on your CPU cores (os.cpu_count() is a good starting point)
num_workers = os.cpu_count() or 4 # Default to 4 if cpu_count() fails
with ThreadPoolExecutor(max_workers=num_workers) as executor:
    # Map the optimize_png function to all found PNG files
    # Use list() to ensure all futures complete before moving on
    list(executor.map(optimize_png, png_files))

print("\nBatch optimization complete.")

import oxipng

try:
    # Strip all possible metadata for maximum size reduction
    oxipng.optimize(
        'input_with_meta.png',
        'output_stripped.png',
        level=4,
        strip=oxipng.StripChunks.all() # Strip all ancillary chunks (like text, EXIF, etc.)
    )
    print("Optimized with maximum metadata stripping.")

    # Preserve all metadata
    oxipng.optimize(
        'input_with_meta.png',
        'output_preserved.png',
        level=4,
        strip=oxipng.StripChunks.none() # Do not request metadata stripping
    )
    print("Optimized while preserving metadata.")

except oxipng.PngError as e:
    print(f"Error during optimization: {e}")
except FileNotFoundError:
    print("Error: Input file 'input_with_meta.png' not found.")

import oxipng
import numpy as np
from PIL import Image
from pathlib import Path

try:
    # Load an image using Pillow and convert to a suitable format (e.g., RGB or RGBA)
    img = Image.open('logo_source.png')
    # Ensure image mode is compatible (e.g., RGB, RGBA, L for grayscale)
    if img.mode not in ('RGB', 'RGBA', 'L'):
        img = img.convert('RGBA') # Convert to RGBA if needed

    # Convert image to a NumPy array
    img_array = np.array(img, dtype=np.uint8)
    height, width = img_array.shape[:2] # Get height and width

    # Get raw bytes from the NumPy array
    raw_bytes = img_array.tobytes()

    # Define the color type based on Pillow's image mode
    if img.mode == 'RGB':
        # For RGB, specify transparency key if needed, e.g., black (0,0,0)
        color_type = oxipng.ColorType.rgb(None) # None means no specific color is transparent
    elif img.mode == 'RGBA':
        color_type = oxipng.ColorType.rgba()
    elif img.mode == 'L': # Grayscale
        color_type = oxipng.ColorType.grayscale()
    else:
        raise ValueError(f"Unsupported image mode for Oxipng: {img.mode}")

    # Create a RawImage object
    raw_image = oxipng.RawImage(
        data=raw_bytes,
        width=width,
        height=height,
        color_type=color_type
    )

    # Optimize the raw image data in memory (level 6 for max compression)
    optimized_png_bytes = raw_image.create_optimized_png(level=6)

    # Save the optimized bytes to a file
    output_path = Path('logo_optimized_from_memory.png')
    output_path.write_bytes(optimized_png_bytes)
    print(f"Successfully optimized image from memory and saved to {output_path}")

except FileNotFoundError:
    print("Error: Source image file 'logo_source.png' not found.")
except ImportError:
    print("Error: Pillow or NumPy not installed. Run 'pip install pillow numpy'")
except oxipng.PngError as e:
    print(f"Error during in-memory optimization: {e}")
except Exception as e:
    print(f"An unexpected error occurred: {e}")

import time
import oxipng
import shutil
import pathlib
import os

# Define the source file for the benchmark
source_file = pathlib.Path('sample.png')

# Check if the source file exists
if not source_file.exists():
    print(f"Error: Benchmark file '{source_file}' not found. Please create a sample PNG file named 'sample.png'.")
    exit()

target_file = pathlib.Path('sample_optimized_benchmark.png')

# Copy the source file to keep the original intact
shutil.copy(source_file, target_file)

original_size = source_file.stat().st_size

print(f"Optimizing '{target_file.name}' (Level 4)...")
start_time = time.perf_counter()
try:
    # Optimize the copied file in place
    oxipng.optimize(target_file, target_file, level=4)
    end_time = time.perf_counter()
    optimized_size = target_file.stat().st_size
    size_diff = original_size - optimized_size
    time_taken = end_time - start_time

    print(f"Original size: {original_size / 1024:.1f} KiB")
    print(f"Optimized size: {optimized_size / 1024:.1f} KiB")
    if original_size > 0:
        print(f"Saved: {size_diff / 1024:.1f} KiB ({size_diff / original_size * 100:.1f}% reduction)")
    else:
        print("Saved: 0.0 KiB (Original size was 0)")
    print(f"Time taken: {time_taken:.3f} seconds")

except oxipng.PngError as e:
    print(f"Optimization failed: {e}")
except Exception as e:
    print(f"An unexpected error occurred: {e}")
finally:
    # Clean up the copied benchmark file
    if target_file.exists():
        try:
            os.remove(target_file)
            print(f"Cleaned up '{target_file.name}'.")
        except OSError as e:
            print(f"Error removing benchmark file '{target_file.name}': {e}")

import oxipng
import sys
from pathlib import Path

input_path = Path('image.png')
output_path = Path('image_optimized.png')

try:
    print(f"Attempting to optimize '{input_path}' to '{output_path}'...")
    oxipng.optimize(input_path, output_path, level=4)
    print(f"Successfully optimized.")

except oxipng.PngError as exc:
    # Handle specific Oxipng errors (e.g., invalid PNG format, processing errors)
    sys.exit(f'Optimization failed for {input_path}: {exc}')

except FileNotFoundError:
    # Handle case where the input file doesn't exist
    sys.exit(f'Error: Input file not found at {input_path}')

except PermissionError:
    # Handle case where script lacks permissions to read input or write output
    sys.exit(f'Error: Permission denied for file operations involving {input_path} or {output_path}')

except Exception as exc:
    # Catch any other unexpected errors during the process
    sys.exit(f'An unexpected error occurred during optimization: {exc}')

{
  "steps": {
    "optimized": {
      "robot": "/image/optimize",
      "use": ":original",
      "priority": "compression-ratio",
      "progressive": false,
      "preserve_meta_data": true
    }
  }
}