Python 图像处理：Pillow 与 OpenCV 实战

from PIL import Image

with Image.open("input.jpg") as im:
    print(im.size, im.mode, im.format)   # (1920, 1080) RGB JPEG
    gray = im.convert("L")
    gray.save("out.png")

im.save("out.jpg", quality=85, optimize=True, progressive=True)
im.save("out.webp", quality=80, method=6)
im.save("out.avif", quality=70)   # 需 pillow-avif-plugin

# 缩放到固定尺寸（可能变形）
im.resize((800, 600), Image.Resampling.LANCZOS)

# 等比缩放到不超过 800x600 的缩略图
im.thumbnail((800, 600), Image.Resampling.LANCZOS)

# 按比例缩放
w, h = im.size
im.resize((w // 2, h // 2), Image.Resampling.BICUBIC)

box = (100, 100, 500, 400)          # (left, upper, right, lower)
crop = im.crop(box)
rotated = im.rotate(45, expand=True, resample=Image.Resampling.BICUBIC)
flipped = im.transpose(Image.Transpose.FLIP_LEFT_RIGHT)

# 粘贴带蒙版
canvas = Image.new("RGB", (1920, 1080), "white")
canvas.paste(crop, (0, 0), mask=alpha_channel)

from PIL import ImageFilter, ImageEnhance, ImageOps

blurred = im.filter(ImageFilter.GaussianBlur(radius=2))
edges = im.filter(ImageFilter.FIND_EDGES)
sharp = im.filter(ImageFilter.UnsharpMask(radius=2, percent=150, threshold=3))

bright = ImageEnhance.Brightness(im).enhance(1.2)
contrast = ImageEnhance.Contrast(bright).enhance(1.1)
saturated = ImageEnhance.Color(contrast).enhance(1.3)

auto = ImageOps.autocontrast(im, cutoff=1)   # 自动对比度拉伸

from PIL import ImageDraw, ImageFont

draw = ImageDraw.Draw(im)
draw.rectangle([10, 10, 200, 60], outline="red", width=3)
draw.line([(0, 0), (100, 100)], fill="blue", width=2)
draw.ellipse([300, 300, 400, 400], fill=(255, 200, 0, 128))

font = ImageFont.truetype("/System/Library/Fonts/PingFang.ttc", 32)
draw.text((20, 20), "中文水印", font=font, fill="white", stroke_width=2, stroke_fill="black")

# 文本尺寸测量
bbox = draw.textbbox((0, 0), "文本", font=font)

from PIL import ImageOps, ExifTags

with Image.open("phone.jpg") as im:
    im = ImageOps.exif_transpose(im)   # 按 EXIF 自动旋转并清除该标签
    im.save("fixed.jpg")

# 读取全部 EXIF
exif = im.getexif()
for tag_id, value in exif.items():
    print(ExifTags.TAGS.get(tag_id, tag_id), value)

def strip_exif(im: Image.Image) -> Image.Image:
    data = list(im.getdata())
    clean = Image.new(im.mode, im.size)
    clean.putdata(data)
    return clean

# 拆分 GIF 帧
with Image.open("anim.gif") as im:
    for i in range(im.n_frames):
        im.seek(i)
        im.convert("RGBA").save(f"frame_{i:03d}.png")

# 合并为 GIF
frames = [Image.open(f"frame_{i:03d}.png") for i in range(10)]
frames[0].save("out.gif", save_all=True, append_images=frames[1:],
               duration=100, loop=0)

# PDF 逐页转图
with Image.open("doc.pdf") as pdf:
    for i in range(len(pdf.pages)):
        page = pdf.pages[i] if hasattr(pdf, "pages") else pdf
        page.convert("RGB").save(f"page_{i}.jpg", quality=90)

import cv2
import numpy as np

img = cv2.imread("input.jpg")            # 默认 BGR！
img_rgb = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
cv2.imwrite("out.jpg", img, [cv2.IMWRITE_JPEG_QUALITY, 90])

h, w = img.shape[:2]

resized = cv2.resize(img, (800, 600), interpolation=cv2.INTER_AREA)  # 缩小用 AREA
M = cv2.getRotationMatrix2D((w / 2, h / 2), 45, 1.0)
rotated = cv2.warpAffine(img, M, (w, h))

# 透视校正（四点映射）
src = np.float32([[56, 65], [368, 52], [28, 387], [389, 390]])
dst = np.float32([[0, 0], [300, 0], [0, 300], [300, 300]])
Mp = cv2.getPerspectiveTransform(src, dst)
warped = cv2.warpPerspective(img, Mp, (300, 300))

hsv = cv2.cvtColor(img, cv2.COLOR_BGR2HSV)

# 提取蓝色区域
lower = np.array([100, 100, 50])
upper = np.array([130, 255, 255])
mask = cv2.inRange(hsv, lower, upper)

# 自适应阈值（光照不均时优于全局阈值）
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
th = cv2.adaptiveThreshold(gray, 255, cv2.ADAPTIVE_THRESH_GAUSSIAN_C,
                           cv2.THRESH_BINARY, 11, 2)

# Otsu 自动阈值
_, otsu = cv2.threshold(gray, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)

blur = cv2.GaussianBlur(img, (5, 5), 0)
median = cv2.medianBlur(img, 5)             # 椒盐噪声首选

edges = cv2.Canny(gray, 50, 150)            # 双阈值滞后

kernel = cv2.getStructuringElement(cv2.MORPH_RECT, (3, 3))
opened = cv2.morphologyEx(mask, cv2.MORPH_OPEN, kernel)    # 去小噪点
closed = cv2.morphologyEx(mask, cv2.MORPH_CLOSE, kernel)   # 补小孔洞

contours, _ = cv2.findContours(opened, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
for c in contours:
    area = cv2.contourArea(c)
    if area < 100:
        continue
    x, y, bw, bh = cv2.boundingRect(c)
    cv2.rectangle(img, (x, y), (x + bw, y + bh), (0, 255, 0), 2)

    # 多边形逼近
    peri = cv2.arcLength(c, True)
    approx = cv2.approxPolyDP(c, 0.02 * peri, True)

cap = cv2.VideoCapture(0)              # 0 = 默认摄像头，或传文件路径
while cap.isOpened():
    ok, frame = cap.read()
    if not ok:
        break
    cv2.imshow("preview", frame)
    if cv2.waitKey(1) & 0xFF == ord("q"):
        break
cap.release()
cv2.destroyAllWindows()

import numpy as np
from PIL import Image
import cv2

# PIL -> ndarray
arr = np.asarray(im)                 # 只读视图
arr_w = np.array(im)                 # 可写副本

# ndarray -> PIL
im2 = Image.fromarray(arr)           # 要求 uint8 且形状 (H,W) 或 (H,W,3/4)

# OpenCV(BGR) <-> PIL(RGB)
def cv2_to_pil(bgr: np.ndarray) -> Image.Image:
    return Image.fromarray(cv2.cvtColor(bgr, cv2.COLOR_BGR2RGB))

def pil_to_cv2(im: Image.Image) -> np.ndarray:
    return cv2.cvtColor(np.array(im), cv2.COLOR_RGB2BGR)

from concurrent.futures import ProcessPoolExecutor
from pathlib import Path

def make_thumb(src: Path, dst: Path, size=(320, 320)) -> Path:
    with Image.open(src) as im:
        im = ImageOps.exif_transpose(im)
        im.thumbnail(size, Image.Resampling.LANCZOS)
        im.convert("RGB").save(dst, "WEBP", quality=80, method=6)
    return dst

def batch(files: list[Path], outdir: Path, workers: int = 8) -> None:
    outdir.mkdir(parents=True, exist_ok=True)
    tasks = [(f, outdir / f"{f.stem}.webp") for f in files]
    with ProcessPoolExecutor(max_workers=workers) as pool:
        for _ in pool.map(lambda a: make_thumb(*a), tasks):
            pass

# JPEG 快速缩略图：让解码器直接输出接近目标尺寸
with Image.open("big.jpg") as im:
    im.draft("RGB", (400, 400))   # 解码器按 1/2、1/4、1/8 降采样
    im = ImageOps.exif_transpose(im)
    im.thumbnail((400, 400), Image.Resampling.LANCZOS)

from PIL import Image

Image.MAX_IMAGE_PIXELS = 50_000_000   # 约 50MP，超过抛 DecompressionBombError

from PIL import UnidentifiedImageError

def safe_open(path: str) -> Image.Image | None:
    try:
        im = Image.open(path)
        im.verify()                 # 校验完整性（会消耗句柄，需重新打开）
        return Image.open(path)
    except (UnidentifiedImageError, OSError):
        return None

def preprocess(bgr: np.ndarray, size=(224, 224)) -> np.ndarray:
    rgb = cv2.cvtColor(bgr, cv2.COLOR_BGR2RGB)
    resized = cv2.resize(rgb, size, interpolation=cv2.INTER_LINEAR)
    x = resized.astype(np.float32) / 255.0
    mean = np.array([0.485, 0.456, 0.406], dtype=np.float32)
    std = np.array([0.229, 0.224, 0.225], dtype=np.float32)
    x = (x - mean) / std
    return x.transpose(2, 0, 1)[None, ...]   # NCHW

from pathlib import Path
from PIL import Image, ImageOps

SIZES = {"sm": (160, 160), "md": (640, 640), "lg": (1280, 1280)}

def thumbnail(src: Path, cache: Path, size_key: str, fmt: str = "webp") -> Path:
    w, h = SIZES[size_key]
    dst = cache / f"{src.stem}_{size_key}.{fmt}"
    if dst.exists() and dst.stat().st_mtime >= src.stat().st_mtime:
        return dst                       # 缓存命中且不过期
    with Image.open(src) as im:
        im.draft("RGB", (w, h))          # 加速
        im = ImageOps.exif_transpose(im)
        im.thumbnail((w, h), Image.Resampling.LANCZOS)
        tmp = dst.with_suffix(".tmp")    # 先写临时文件再原子重命名
        im.convert("RGB").save(tmp, fmt.upper(), quality=82, method=6)
        tmp.replace(dst)
    return dst

def prepare_for_ocr(bgr: np.ndarray) -> np.ndarray:
    gray = cv2.cvtColor(bgr, cv2.COLOR_BGR2GRAY)
    gray = cv2.bilateralFilter(gray, 9, 75, 75)     # 保边去噪
    _, th = cv2.threshold(gray, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)
    # 轻微膨胀，连接断裂笔画
    kernel = cv2.getStructuringElement(cv2.MORPH_RECT, (2, 2))
    return cv2.dilate(th, kernel, iterations=1)