# Computational Photography

> Use when implementing computational photography pipelines.

- Skill: `loopyluci/computational-photography` (Agent Skill)
- Install (CLI): `npx skillmds@latest add loopyluci/computational-photography`
- Raw SKILL.md: https://api.skillmd.com/api/skills/loopyluci/computational-photography/raw
- Safety review: pending (external: skill-scanner PASS, skillspector PASS)
- Works with: Claude Code, Claude.ai, OpenAI Codex
- Category: Coding & Dev Tools
- License: MIT
- Author: LoopyLuci (https://skillmd.com/u/loopyluci)
- Updated: 2026-09-08
- Page: https://skillmd.com/skills/loopyluci/computational-photography

---


# Computational Photography

Implementing computational photography pipelines — from HDR merging and burst processing through denoising, super-resolution, and neural rendering.

## When to Use

- Building camera apps with advanced features
- Implementing HDR, night mode, or portrait mode
- Image enhancement (denoising, super-resolution)
- Computational imaging pipelines
- Neural rendering and image synthesis

## Photography Pipeline

```python
import cv2
import numpy as np

class ComputationalPhotography:
    """Computational photography pipeline components."""
    
    @staticmethod
    def hdr_merge(images: List[np.array], exposures: List[float]) -> np.array:
        """Merge multiple exposures into HDR image."""
        merge_debevec = cv2.createMergeDebevec()
        hdr = merge_debevec.process(images, times=np.array(exposures))
        tonemap = cv2.createTonemapReinhard(gamma=2.2)
        ldr = tonemap.process(hdr)
        return np.clip(ldr * 255, 0, 255).astype(np.uint8)
    
    @staticmethod
    def burst_denoise(burst: List[np.array]) -> np.array:
        """Denoise by averaging aligned burst frames."""
        aligned = []
        for i, frame in enumerate(burst):
            if i == 0:
                aligned.append(frame)
            else:
                # Align frames (simplified)
                warp_matrix = np.eye(2, 3, dtype=np.float32)
                aligned_frame = cv2.warpAffine(frame, warp_matrix, 
                                                (frame.shape[1], frame.shape[0]))
                aligned.append(aligned_frame)
        return np.mean(aligned, axis=0).astype(np.uint8)
```

## Verification Checklist

- [ ] Image capture pipeline defined (raw → processed → output)
- [ ] HDR merging working across exposure brackets
- [ ] Denoising effective (PSNR, SSIM vs ground truth)
- [ ] Super-resolution produces real detail (not just sharpening)
- [ ] Alignment robust to handheld motion
- [ ] Processing time < capture interval for real-time
- [ ] Memory-efficient processing for high-resolution images
- [ ] Neural methods (if used) have acceptable latency