# OCR Processing - Text extraction
import pytesseract
from PIL import Image

# Configure Tesseract path (if needed)
# pytesseract.pytesseract.tesseract_cmd = '/usr/bin/tesseract'

img = Image.open("document.jpg")
text = pytesseract.image_to_string(img, lang='eng')
print(text[:200])  # First 200 characters

# Get bounding boxes for text
data = pytesseract.image_to_data(img, output_type=pytesseract.Output.DICT)
for i, word in enumerate(data['text']):
    if word:
        x, y, w, h = data['left'][i], data['top'][i], data['width'][i], data['height'][i]
        print(f"Word: {word} | Position: ({x},{y}) Size: {w}x{h}")

# Generative Art - Creative application
from PIL import Image, ImageDraw
import random

img = Image.new('RGB', (800, 800), (255, 255, 255))
draw = ImageDraw.Draw(img)

# Generate random geometric pattern
for _ in range(1000):
    x1, y1 = random.randint(0, 800), random.randint(0, 800)
    x2, y2 = x1 + random.randint(-100, 100), y1 + random.randint(-100, 100)
    color = (random.randint(0, 255), random.randint(0, 255), random.randint(0, 255))
    draw.line([x1, y1, x2, y2], fill=color, width=random.randint(1, 5))

img.save("generative_art.jpg")

# Image Steganography - Security technique
def hide_message(image_path, message, output_path):
    img = Image.open(image_path)
    binary_message = ''.join(format(ord(c), '08b') for c in message) + '1111111111111110'
    
    pixels = list(img.getdata())
    new_pixels = []
    bit_index = 0
    
    for pixel in pixels:
        if bit_index < len(binary_message):
            r, g, b = pixel[:3]
            r = (r & ~1) | int(binary_message[bit_index])
            bit_index += 1
            new_pixels.append((r, g, b))
        else:
            new_pixels.append(pixel)
    
    img.putdata(new_pixels)
    img.save(output_path)

hide_message("cover.jpg", "Secret message", "stego.png")

# Interview Power Move: Custom Filter Implementation
import numpy as np
from PIL import Image

def apply_sepia(img):
    # Convert to numpy array
    img_array = np.array(img)
    
    # Sepia matrix (BT.709 coefficients)
    sepia_matrix = np.array([
        [0.393, 0.769, 0.189],
        [0.349, 0.686, 0.168],
        [0.272, 0.534, 0.131]
    ])
    
    # Apply matrix multiplication
    sepia_array = img_array @ sepia_matrix.T
    sepia_array = np.clip(sepia_array, 0, 255).astype(np.uint8)
    
    return Image.fromarray(sepia_array)

sepia_img = apply_sepia(Image.open("input.jpg"))
sepia_img.save("sepia.jpg")

# Pro Tip: Memory-Mapped Processing for Gigapixel Images
import numpy as np
from PIL import Image

def process_gigapixel(image_path):
    # Create memory-mapped array
    img = Image.open(image_path)
    mmap_file = np.memmap('temp.mmap', dtype='uint8', mode='w+', shape=img.size[::-1] + (3,))
    
    # Process in chunks
    chunk_size = (1000, 1000)
    for y in range(0, img.height, chunk_size[1]):
        for x in range(0, img.width, chunk_size[0]):
            box = (x, y, min(x+chunk_size[0], img.width), min(y+chunk_size[1], img.height))
            chunk = np.array(img.crop(box))
            mmap_file[y:box[3], x:box[2]] = chunk
    
    # Process entire image in memory-mapped array
    mmap_file = np.where(mmap_file > 128, 255, 0)  # Binarize
    Image.fromarray(mmap_file).save("processed.jpg")

process_gigapixel("gigapixel.tiff")

# Real-World Case Study: E-commerce Product Pipeline
import boto3
from PIL import Image
import io

def process_product_image(s3_bucket, s3_key):
    # 1. Download from S3
    s3 = boto3.client('s3')
    response = s3.get_object(Bucket=s3_bucket, Key=s3_key)
    img = Image.open(io.BytesIO(response['Body'].read()))
    
    # 2. Standardize dimensions
    img = img.convert("RGB")
    img = img.resize((1200, 1200), Image.LANCZOS)
    
    # 3. Remove background (simplified)
    # In practice: use rembg or AWS Rekognition
    img = remove_background(img)
    
    # 4. Generate variants
    variants = {
        "web": img.resize((800, 800)),
        "mobile": img.resize((400, 400)),
        "thumbnail": img.resize((100, 100))
    }
    
    # 5. Upload to CDN
    for name, variant in variants.items():
        buffer = io.BytesIO()
        variant.save(buffer, "JPEG", quality=95)
        s3.upload_fileobj(
            buffer, 
            "cdn-bucket", 
            f"products/{s3_key.split('/')[-1].split('.')[0]}_{name}.jpg",
            ExtraArgs={'ContentType': 'image/jpeg', 'CacheControl': 'max-age=31536000'}
        )
    
    # 6. Generate WebP version
    webp_buffer = io.BytesIO()
    img.save(webp_buffer, "WEBP", quality=85)
    s3.upload_fileobj(webp_buffer, "cdn-bucket", f"products/{s3_key.split('/')[-1].split('.')[0]}.webp")

process_product_image("user-uploads", "products/summer_dress.jpg")