Pillow 1-Bit Threshold & Dithering Studio

from PIL import Image

def fast_threshold_lut(input_path, output_path, threshold=128):
    """
    Blazing-fast 1-bit thresholding using internal C lookup tables.
    """
    with Image.open(input_path) as img:
        # Convert to 8-bit grayscale first
        gray = img.convert("L")
        
        # Build 256-entry lookup table in C
        # 1-bit output mode="1" (0 = Black, 255 = White)
        binary = gray.point(lambda p: 255 if p > threshold else 0, mode="1")
        
        binary.save(output_path)
        print(f"Binarized with threshold {threshold} -> {output_path}")

# Usage
fast_threshold_lut("document.png", "document_binary.png", threshold=135)

import numpy as np
from PIL import Image

def compute_otsu_threshold(gray_img):
    """
    Computes optimal threshold value using Otsu's method.
    """
    hist = gray_img.histogram()
    total_pixels = sum(hist)
    
    current_max = 0.0
    threshold = 0
    sum_total = sum(i * hist[i] for i in range(256))
    sum_b, weight_b = 0.0, 0.0
    
    for i in range(256):
        weight_b += hist[i]
        if weight_b == 0:
            continue
        weight_f = total_pixels - weight_b
        if weight_f == 0:
            break
            
        sum_b += i * hist[i]
        mean_b = sum_b / weight_b
        mean_f = (sum_total - sum_b) / weight_f
        
        # Inter-class variance
        var_between = weight_b * weight_f * (mean_b - mean_f) ** 2
        if var_between > current_max:
            current_max = var_between
            threshold = i
            
    return threshold

def otsu_binarize(input_path, output_path):
    with Image.open(input_path) as img:
        gray = img.convert("L")
        opt_thresh = compute_otsu_threshold(gray)
        print(f"Optimal Otsu Cutoff Found: {opt_thresh}")
        binary = gray.point(lambda p: 255 if p > opt_thresh else 0, mode="1")
        binary.save(output_path)

# Usage
# otsu_binarize("scanned_receipt.jpg", "receipt_clean.png")

from PIL import Image

def convert_to_dithered_1bit(input_path, output_path):
    """
    Converts photos to 1-bit binary with Floyd-Steinberg error diffusion.
    """
    with Image.open(input_path) as img:
        # Convert RGB to Grayscale first
        gray = img.convert("L")
        
        # Convert to mode 1 with Floyd-Steinberg dithering enabled
        dithered = gray.convert("1", dither=Image.Dither.FLOYDSTEINBERG)
        
        dithered.save(output_path)
        print(f"Saved dithered bitmap: {output_path}")

# Usage
# convert_to_dithered_1bit("portrait.jpg", "eink_portrait.png")

from PIL import Image, ImageEnhance, ImageFilter

def preprocess_for_ocr(input_path, output_path):
    """
    Cleans noisy scanned documents, receipts, and invoices for Tesseract OCR.
    """
    with Image.open(input_path) as img:
        # 1. Grayscale
        gray = img.convert("L")
        
        # 2. Sharpen text contours
        enhanced = ImageEnhance.Sharpness(gray).enhance(2.0)
        
        # 3. Boost contrast
        contrast = ImageEnhance.Contrast(enhanced).enhance(1.8)
        
        # 4. Clean 1-bit binary threshold
        binary = contrast.point(lambda p: 255 if p > 140 else 0, mode="1")
        
        # Save as lossless CCITT TIFF or PNG
        binary.save(output_path, compression="group4" if output_path.endswith(".tif") else None)
        return binary

# Usage
# preprocess_for_ocr("blurry_receipt.jpg", "clean_for_tesseract.png")