Pillow Watermark Generator & Compositor

from PIL import Image, ImageDraw, ImageFont

def add_text_watermark(input_path, output_path, text="© Photography", opacity=128):
    """
    Adds semi-transparent text watermark with shadow to any image.
    """
    with Image.open(input_path).convert("RGBA") as base:
        # 1. Create transparent text layer
        txt_layer = Image.new("RGBA", base.size, (255, 255, 255, 0))
        draw = ImageDraw.Draw(txt_layer)
        
        # 2. Dynamic font sizing (3.5% of longest edge)
        font_size = max(18, int(max(base.size) * 0.035))
        try:
            font = ImageFont.truetype("arial.ttf", font_size)
        except IOError:
            font = ImageFont.load_default(size=font_size)   # scalable built-in font (Pillow 10.1+)
            
        # 3. Calculate bottom-right positioning with padding
        bbox = draw.textbbox((0, 0), text, font=font)
        text_w = bbox[2] - bbox[0]
        text_h = bbox[3] - bbox[1]
        
        pad = int(font_size * 0.75)
        x = base.width - text_w - pad
        y = base.height - text_h - pad
        
        # Draw soft shadow (black 40% opacity)
        draw.text((x + 2, y + 2), text, font=font, fill=(0, 0, 0, int(opacity * 0.7)))
        # Draw main watermark text
        draw.text((x, y), text, font=font, fill=(255, 255, 255, opacity))
        
        # 4. Composite & save as high quality JPEG/PNG
        watermarked = Image.alpha_composite(base, txt_layer)
        watermarked.convert("RGB").save(output_path, "JPEG", quality=95)
        print(f"Watermarked: {output_path}")

# Usage
add_text_watermark("landscape.jpg", "landscape_watermarked.jpg")

from PIL import Image

def overlay_logo_watermark(base_path, logo_path, output_path, scale_pct=0.2, opacity=0.6):
    """
    Overlays a PNG logo onto a base image with custom scale and opacity.
    """
    with Image.open(base_path).convert("RGBA") as base, Image.open(logo_path).convert("RGBA") as logo:
        # 1. Resize logo proportional to base image width
        target_w = int(base.width * scale_pct)
        target_h = int(logo.height * (target_w / logo.width))
        logo_resized = logo.resize((target_w, target_h), Image.Resampling.LANCZOS)
        
        # 2. Adjust logo transparency
        r, g, b, alpha = logo_resized.split()
        alpha = alpha.point(lambda p: int(p * opacity))
        logo_resized.putalpha(alpha)
        
        # 3. Paste in bottom-right corner with 20px padding
        pos_x = base.width - target_w - 20
        pos_y = base.height - target_h - 20
        
        base.paste(logo_resized, (pos_x, pos_y), mask=logo_resized)
        base.convert("RGB").save(output_path, "JPEG", quality=95)

# Usage
# overlay_logo_watermark("product.jpg", "company_logo.png", "product_branded.jpg")

import math
from PIL import Image, ImageDraw, ImageFont

def add_tiled_watermark(input_path, output_path, text="PROOF — DO NOT COPY", opacity=60):
    with Image.open(input_path).convert("RGBA") as base:
        # Create transparent canvas
        overlay = Image.new("RGBA", base.size, (255, 255, 255, 0))
        draw = ImageDraw.Draw(overlay)
        
        font_size = max(16, int(base.width * 0.025))
        try:
            font = ImageFont.truetype("arial.ttf", font_size)
        except IOError:
            font = ImageFont.load_default(size=font_size)   # scalable built-in font (Pillow 10.1+)
            
        step_x = int(font_size * 10)
        step_y = int(font_size * 6)
        
        for y in range(0, base.height + step_y, step_y):
            for x in range(0, base.width + step_x, step_x):
                draw.text((x, y), text, font=font, fill=(255, 255, 255, opacity))
                
        # Rotate overlay by -30 degrees
        rotated = overlay.rotate(-30, expand=False, resample=Image.Resampling.BICUBIC)
        
        watermarked = Image.alpha_composite(base, rotated)
        watermarked.convert("RGB").save(output_path, "JPEG", quality=90)

# Usage
# add_tiled_watermark("client_proof.jpg", "client_proof_watermarked.jpg")

from pathlib import Path
from concurrent.futures import ThreadPoolExecutor
from PIL import Image, ImageDraw, ImageFont

def process_file(src, dst_dir, text):
    try:
        dst = Path(dst_dir) / src.name
        with Image.open(src).convert("RGBA") as base:
            txt_layer = Image.new("RGBA", base.size, (255, 255, 255, 0))
            draw = ImageDraw.Draw(txt_layer)
            font_size = max(18, int(max(base.size) * 0.03))
            try:
                font = ImageFont.truetype("arial.ttf", font_size)
            except IOError:
                font = ImageFont.load_default(size=font_size)   # scalable built-in font (Pillow 10.1+)
                
            draw.text((30, base.height - font_size - 30), text, font=font, fill=(255, 255, 255, 140))
            Image.alpha_composite(base, txt_layer).convert("RGB").save(dst, "JPEG", quality=92)
        return f"Watermarked: {src.name}"
    except Exception as e:
        return f"Failed {src.name}: {e}"

def batch_watermark(input_folder, output_folder, text="© Brand 2026"):
    Path(output_folder).mkdir(parents=True, exist_ok=True)
    files = [p for p in Path(input_folder).glob("*") if p.suffix.lower() in (".jpg", ".jpeg", ".png")]
    with ThreadPoolExecutor(max_workers=8) as ex:
        results = ex.map(lambda f: process_file(f, output_folder, text), files)
        for r in results:
            print(r)