Detailed introduction and code examples of Python Pillow library

pip install Pillow

from PIL import Image

# Open the imageimg = ("")
print(f"Format: {}, size: {}, model: {}")

# Save the image (automatically recognize the format)("")

# Convert format("", "WEBP")

# Adjust sizeresized = ((300, 200))

# Rotate (expand parameter prevents cropping)rotated = (45, expand=True)

# Crop (left, upper, right, lower)cropped = ((100, 100, 400, 400))

# Thumbnail generation (maintaining proportion)((128, 128))
("")

from PIL import ImageFilter, ImageEnhance

# Apply filtersblurred = ((radius=2))
contour = ()

# Color adjustmentgray = ("L")  # Turn to grayscaleenhancer = (img)
contrast_img = (2.0)  # 2x contrast enhancement
# Adjust brightnessbright_enhancer = (img)
bright_img = bright_enhancer.enhance(1.5)

from PIL import ImageDraw, ImageFont

# Create a new canvascanvas = ("RGB", (500, 500), color=(255, 255, 255))
draw = (canvas)

# Draw shapes([50, 50, 200, 200], fill="red", outline="blue")
([250, 250, 400, 400], fill="yellow")

# Add texttry:
    font = ("", 24)
except IOError:
    font = ImageFont.load_default()
((100, 300), "Hello Pillow!", fill="black", font=font)

()

# Image synthesisoverlay = ("RGBA", , (255, 0, 0, 100))
composite = Image.alpha_composite(("RGBA"), overlay)

# Pixel level operationpixels = ()
for y in range():
    for x in range():
        r, g, b = pixels[x, y]
        pixels[x, y] = (r//2, g//2, b//2)  # Darkening effect
# Create a GIFimages = [img, rotated, cropped]
images[0].save("", save_all=True, append_images=images[1:], duration=500, loop=0)

def add_watermark(input_path, output_path, text):
    base = (input_path).convert("RGBA")
    txt = ("RGBA", , (255,255,255,0))
    
    draw = (txt)
    font = ("", 36)
    
    # Calculate text position    text_width, text_height = (text, font)
    x =  - text_width - 10
    y =  - text_height - 10
    
    ((x, y), text, font=font, fill=(255,255,255,128))
    
    combined = Image.alpha_composite(base, txt)
    ("RGB").save(output_path)

add_watermark("", "", "© Your Brand")

with ("large_image.tiff") as img:
    # Process images

from PIL import Image, ImageChops

# Separate RGB channelsr, g, b = ()

# Adjust the channel order when merging (for example, create pseudo-infrared effects)modified = ("RGB", (b, g, r))

# Channel mixing (mathematical operations)diff = (img1, img2)  # Pixel Difference Graphblended = (img1, img2, alpha=0.3)  # Image overlay

# CMYK to RGBcmyk_img = ("cmyk_image.tiff").convert("RGB")

# Convert to HSV color space (requires supplemented by third-party libraries)# Note: Pillow does not natively support HSV operations, but can be implemented through numpyimport numpy as np
hsv_array = (("HSV"))
# ...processing HSV arrays...modified_img = (hsv_array, "HSV").convert("RGB")

# Read EXIF ​​dataexif_data = img._getexif()
if exif_data:
    from  import TAGS
    for tag_id, value in exif_data.items():
        tag_name = (tag_id, tag_id)
        print(f"{tag_name}: {value}")

# Rotate the image (automatically corrected according to EXIF ​​direction information)from PIL import ImageOps
fixed_img = ImageOps.exif_transpose(img)

# Process large images in blockstile_size = 512
for y in range(0, , tile_size):
    for x in range(0, , tile_size):
        box = (x, y, x+tile_size, y+tile_size)
        tile = (box)
        # Handle chunking...        (tile, box)

# Use LA mode to replace RGBA (save 25% memory)gray_alpha = ("LA")

# Use numpy to speed up pixel processingimport numpy as np
arr = (img)
arr = arr // 2  # Rapid darkening treatmentfast_processed = (arr)

from PIL import Image, ImageDraw, ImageFont, ImageFilter
import random

def generate_captcha(text, size=(200, 80)):
    img = ("RGB", size, (255,255,255))
    draw = (img)
    
    # Draw the interference line    for _ in range(8):
        start = ((0, size[0]), (0, size[1]))
        end = ((0, size[0]), (0, size[1]))
        ([start, end], fill=((0,255), (0,255), (0,255)), width=2)
    
    # Add text    font = ("", 36)
    text_width, text_height = ((0,0), text, font=font)[2:]
    x = (size[0] - text_width) / 2
    y = (size[1] - text_height) / 2
    
    # Text distortion    for i, char in enumerate(text):
        (
            (x + i*30 + (-5,5), y + (-5,5)),
            char,
            font=font,
            fill=((0,160), (0,160), (0,160))
        )
    
    # Add filters    img = (ImageFilter.SMOOTH_MORE)
    return img

captcha = generate_captcha("3A4B")
("")

import os
from PIL import Image, ImageOps

def batch_process(input_dir, output_dir, process_func):
    (output_dir, exist_ok=True)
    for filename in (input_dir):
        if ().split('.')[-1] not in ['jpg', 'png', 'jpeg']:
            continue
        
        with ((input_dir, filename)) as img:
            processed = process_func(img)
            ((output_dir, filename))

# Example processing function: Convert to sketch styledef sketch_effect(img):
    gray = ("L")
    invert = (gray)
    blur = ((3))
    return (gray, blur)

batch_process("./photos", "./processed", sketch_effect)

histogram = ()
# Get the R channel histogram (first 256 values)red_hist = histogram[:256]

# Draw a simple histogram (requires matplotlib)import  as plt
(figsize=(10,4))
("Red Channel Histogram")
(range(256), red_hist, color='red')
()

from PIL import ImageFilter

edges = ("L").filter(ImageFilter.FIND_EDGES)
edges = (lambda x: 255 if x > 50 else 0)  # Binary()

try:
    with ("") as img:
        # Processing images...except IOError as e:
    print(f"Unable to open image file: {str(e)}")
except :
    print("The image size is too large, please check if it is safe!")

# Force release image memory()  # Explicitly close
# Use with statements to automatically managewith ("large_image.tiff") as img:
    thumbnail = ()
    ((1024, 1024))
("")  # Note: The original image is closed at this time

import cv2
import numpy as np
from PIL import Image

# Pillow -> OpenCV
pil_img = ("")
cv_img = (pil_img.convert('RGB'))[:, :, ::-1]  # RGB to BGR

# OpenCV -> Pillow
cv_img = (cv_img, cv2.COLOR_BGR2RGB)
pil_img = (cv_img)

import  as plt

(img)
('off')
("Pillow Image Display")
()

from PIL import ImageFilter

class CustomFilter():
    name = "CustomSharpen"
    filterargs = (3, 3), 16, 0, (
        -1, -1, -1,
        -1, 24, -1,
        -1, -1, -1
    )

sharpened = (CustomFilter())

# After installing the additional decoder, it can support WebP animations, etc.# Need to install: pip install pillow-heifimport pillow_heif
heif_file = pillow_heif.open_heif("")
heif_img = (
    heif_file.mode,
    heif_file.size,
    heif_file.data,
    "raw",
    heif_file.mode,
    heif_file.stride,
)

("", 
        quality=85,        # Mass Value (1-100)        optimize=True,    # Enable optimization        progressive=True) # Progressive JPEG

with ("") as img:
    for frame in (img):
        # Process every frame        (f"frame_{()}.png")

import numpy as np
from PIL import Image

def histogram_matching(source, template):
    """Match the histogram of the source image to the template image"""
    src = (('L')).flatten()
    tgt = (('L')).flatten()
    
    # Calculate the cumulative distribution function    src_vals, src_counts = (src, return_counts=True)
    tgt_vals, tgt_counts = (tgt, return_counts=True)
    
    src_cdf = (src_counts) / 
    tgt_cdf = (tgt_counts) / 
    
    # Create a mapping table    lut = (src_cdf, tgt_cdf, tgt_vals)
    return (lut)

source_img = ("")
template_img = ("")
matched = histogram_matching(source_img, template_img)

from PIL import ImageOps

# Otsu automatic threshold algorithmgray = ('L')
thresh = (lambda x: 255 if x > 130 else 0)  # Manual threshold
# Automatic threshold (scikit-image required)from  import threshold_otsu
arr = (gray)
thresh_val = threshold_otsu(arr)
auto_thresh = ((arr > thresh_val).astype(np.uint8) * 255)

# pydicom needs to be installedimport pydicom
from PIL import Image

ds = ("")
arr = ds.pixel_array.astype(float)
arr = (arr - ()) / (() - ()) * 255
medical_img = ((np.uint8))
medical_img.save("mri_preview.png")

# Load multi-band imageswith ("") as img:
    bands = [(band) for band in ('R', 'G', 'B', 'NIR')]

# Calculate NDVI (Normalized Vegetation Index)red = (bands[0], dtype=np.float32)
nir = (bands[3], dtype=np.float32)
ndvi = (nir - red) / (nir + red + 1e-10)  # Prevent division by zero
# Visualize NDVIndvi_img = (np.uint8((ndvi + 1) * 127.5))
ndvi_img.save("ndvi_map.png")

import glob
from PIL import Image, ImageMath

# Load the focus stack imagez_images = [(f) for f in sorted(("z_stack_*.tif"))]

# Create a fully focused imagedef focus_metric(pixels):
    return (pixels)  # Use standard deviation as a clarity indicator
depth_map = (z_images[0].size[::-1])
final_img = np.zeros_like((z_images[0]))

for i in range(z_images[0].height):
    for j in range(z_images[0].width):
        pixels = [(img)[i,j] for img in z_images]
        sharpness = [focus_metric(p) for p in pixels]
        best_idx = (sharpness)
        final_img[i,j] = pixels[best_idx]
        depth_map[i,j] = best_idx

(final_img).save("")
(np.uint8(depth_map * 255 / len(z_images))).save("depth_map.png")

import cupy as cp
from PIL import Image

def gpu_filter(img):
    # Convert to GPU    img_gpu = (img)
    
    # Custom kernel functions (edge ​​detection)    kernel = ([[-1, -1, -1],
                      [-1,  8, -1],
                      [-1, -1, -1]], dtype=cp.float32)
    
    # Convolution operation    filtered = cp.zeros_like(img_gpu)
    for c in range(3):
        filtered[:, :, c] = cp.convolve2d(img_gpu[:, :, c], kernel, mode='same')
    
    # Return to CPU    return ((filtered).astype(np.uint8))

original = ("gpu_demo.jpg")
accelerated = gpu_filter(original)

from torchvision import transforms
from PIL import Image

class AdvancedAugmentation:
    def __init__(self):
         = ([
            ([
                lambda x: .adjust_sharpness(x, 2),
                lambda x: (x).enhance(0.8)
            ], p=0.5),
            (distortion_scale=0.3),
            (brightness=0.2, contrast=0.2)
        ])
    
    def __call__(self, img):
        return (img)

augmenter = AdvancedAugmentation()
img = ("training_sample.jpg")
augmented = augmenter(img)

from PIL import Image, ImageFile

class RAWDecoder():
    def decode(self, buffer):
        # Implement custom RAW format parsing        raw_data = self._parse_custom_format(buffer)
        self.set_as_raw(bytes(raw_data))
        return -1, 0

# Register the decoderImage.register_decoder("MYRAW", RAWDecoder)
Image.register_extensions("MYRAW", [".raw"])

from PIL import ImageFilter

class KaleidoscopeFilter():
    name = "Kaleidoscope"
    filterargs = (5, 5), 16, 0, (
        1, 0, 0, 0, 1,
        0, 0, 0, 0, 0,
        0, 0, 0, 0, 0,
        0, 0, 0, 0, 0,
        1, 0, 0, 0, 1
    )

(KaleidoscopeFilter()).show()

# Build a REST API using FastAPIfrom fastapi import FastAPI, File, UploadFile
from PIL import Image
import io

app = FastAPI()

@("/enhance")
async def enhance_image(file: UploadFile = File(...)):
    img = ((await ()))
    
    # Execute processing pipeline    enhanced = (('RGB')
                .filter()
                .enhance(contrast=1.2)
                .resize((1024, 768)))
    
    byte_arr = ()
    (byte_arr, format='JPEG')
    return Response(content=byte_arr.getvalue(), media_type="image/jpeg")

import unittest
from PIL import Image, ImageChops

class ImageTests():
    def test_watermark(self):
        original = ('RGB', (800, 600), 'white')
        watermarked = add_watermark((), "Test")
        
        # Verify the location and content of the watermark        diff = (original, watermarked)
        (()[2], 700)  # Check the changes in the lower right corner        
    def test_performance(self):
        large_img = ('RGB', (10000, 10000))
        start = ()
        large_img.thumbnail((1000, 1000))
        (() - start, 1.0)

# Combining Pillow with deep learning modelsdef style_transfer(content_img, style_img):
    # Load pretrained models (torch and torchvision need to be installed)    from  import vgg19
    model = vgg19(pretrained=True).()
    
    # Feature extraction and style transfer algorithm...    # (Implement specific migration logic here)    
    return (output)

content = ("")
style = ("starry_night.jpg")
artwork = style_transfer(content, style)

from PIL import Image, ImageDraw
import qrcode

def animated_qr(data, logo_path):
    base = (data).convert('RGBA')
    logo = (logo_path).resize((100, 100))
    
    frames = []
    for angle in range(0, 360, 30):
        rotated_logo = (angle)
        frame = ()
        frame.alpha_composite(rotated_logo, 
            ((-100)//2, (-100)//2))
        (frame)
    
    frames[0].save("qr_animation.gif", 
                  save_all=True, 
                  append_images=frames[1:], 
                  duration=200, 
                  loop=0,
                  optimize=True)

import tracemalloc
from PIL import Image

()

# Test code blockwith ("") as img:
    processed = ((2000, 2000))
    ("")

snapshot = tracemalloc.take_snapshot()
top_stats = ('lineno')
print("[Top 10 Memory Consumption]")
for stat in top_stats[:10]:
    print(stat)

# Use cProfile to analyze processing flowpython -m cProfile -s cumulative image_processor.py

# Safe Font Loading Solutiondef safe_font_loading(font_path, fallback_size=20):
    try:
        return (font_path, size=fallback_size)
    except IOError:
        print(f"Font {font_path} Loading failed，使用系统默认Font")
        return ImageFont.load_default()

from pathlib import Path

input_path = Path("input_images") / "special_chars_test.jpg"
output_path = input_path.with_name(f"processed_{input_path.name}")