"""Virtual-tripod video stabilization: warp every frame back to a reference frame's coordinate system so the video becomes a fixed-camera shot, then crop to the common valid region. Motion model: per consecutive-frame pair, track features (Shi-Tomasi + LK optical flow) and fit a global transform with RANSAC (dynamic foreground is rejected as outliers). Transforms are chained to get frame_i -> frame_0, and each frame is warped by the inverse. Model choice: 'similarity' (translation+rotation+scale, robust) or 'homography' (exact for rotation-only camera motion; can overfit when features are sparse). Diagnostics per video: cumulative drift, crop loss ratio, and background residual (median optical-flow magnitude on static regions after warping) — a large residual means parallax from camera translation, i.e. a single 2D warp is insufficient. Usage: python tripod_lock.py input.mp4 [input2.mp4 ...] [--model similarity|homography] [--out-dir output] """ import argparse import json from pathlib import Path import cv2 import numpy as np def read_video(path): cap = cv2.VideoCapture(str(path)) fps = cap.get(cv2.CAP_PROP_FPS) frames = [] while True: ok, f = cap.read() if not ok: break frames.append(f) cap.release() if not frames: raise RuntimeError(f"no frames decoded from {path}") return frames, fps def estimate_pairwise(g0, g1, model, feature_mask=None): p0 = cv2.goodFeaturesToTrack( g0, maxCorners=1000, qualityLevel=0.01, minDistance=12, mask=feature_mask ) if p0 is None or len(p0) < 20: raise RuntimeError("too few features to track") p1, st, _ = cv2.calcOpticalFlowPyrLK(g0, g1, p0, None) st = st.ravel().astype(bool) if model == "similarity": a, _ = cv2.estimateAffinePartial2D( p0[st], p1[st], method=cv2.RANSAC, ransacReprojThreshold=2.0 ) if a is None: raise RuntimeError("RANSAC failed to fit similarity transform") return np.vstack([a, [0.0, 0.0, 1.0]]) h, _ = cv2.findHomography(p0[st], p1[st], cv2.RANSAC, 2.0) if h is None: raise RuntimeError("RANSAC failed to fit homography") return h def cumulative_transforms(grays, model, feature_mask=None): cums = [np.eye(3)] for i in range(1, len(grays)): t = estimate_pairwise(grays[i - 1], grays[i], model, feature_mask) cums.append(t @ cums[-1]) return cums def common_valid_rect_from_mats(mats, w, h): """Intersection over frames of the axis-aligned inner rect of each warped quad.""" corners = np.array([[0, 0], [w, 0], [w, h], [0, h]], np.float64).reshape(-1, 1, 2) x0, y0, x1, y1 = 0.0, 0.0, float(w), float(h) for m in mats: pts = cv2.perspectiveTransform(corners, m).reshape(-1, 2) xs, ys = np.sort(pts[:, 0]), np.sort(pts[:, 1]) x0, y0 = max(x0, xs[1]), max(y0, ys[1]) x1, y1 = min(x1, xs[2]), min(y1, ys[2]) if x1 - x0 < 64 or y1 - y0 < 64: raise RuntimeError("camera drift too large: common valid region collapsed") return int(np.ceil(x0)), int(np.ceil(y0)), int(np.floor(x1)), int(np.floor(y1)) def background_residual(warped_grays, n_samples=6): """Median flow magnitude between warped frame pairs on RANSAC-consistent (static) regions. Measures parallax/estimation residual after locking.""" idx = np.linspace(0, len(warped_grays) - 1, n_samples).astype(int) mags = [] for a, b in zip(idx[:-1], idx[1:]): p0 = cv2.goodFeaturesToTrack( warped_grays[a], maxCorners=500, qualityLevel=0.01, minDistance=15 ) if p0 is None: continue p1, st, _ = cv2.calcOpticalFlowPyrLK(warped_grays[a], warped_grays[b], p0, None) st = st.ravel().astype(bool) d = np.linalg.norm((p1[st] - p0[st]).reshape(-1, 2), axis=1) # static background = the majority cluster of near-zero motion; dynamic # foreground shows large flow and is excluded by taking the lower half mags.append(np.median(d[d < np.percentile(d, 50)])) return float(np.median(mags)) def process(path, out_dir, model, extra_crop=(0, 0, 0, 0), start_frame=0, end_frame=None, ref_frame="0", track_roi=None): path = Path(path) frames, fps = read_video(path) frames = frames[start_frame:end_frame] h, w = frames[0].shape[:2] grays = [cv2.cvtColor(f, cv2.COLOR_BGR2GRAY) for f in frames] ref = len(frames) // 2 if ref_frame == "middle" else int(ref_frame) feature_mask = None if track_roi is not None: x, y, rw, rh = track_roi feature_mask = np.zeros((h, w), np.uint8) feature_mask[y:y + rh, x:x + rw] = 255 cums = cumulative_transforms(grays, model, feature_mask) # frame i -> reference frame coords: cums[ref] @ inv(cums[i]) mats = [cums[ref] @ np.linalg.inv(c) for c in cums] warped = [cv2.warpPerspective(f, m, (w, h)) for f, m in zip(frames, mats)] x0, y0, x1, y1 = common_valid_rect_from_mats(mats, w, h) cl, cr, ct, cb = extra_crop # additional left/right/top/bottom trim x0, x1, y0, y1 = x0 + cl, x1 - cr, y0 + ct, y1 - cb if x1 - x0 < 64 or y1 - y0 < 64: raise RuntimeError("extra crop leaves no usable frame area") cw, ch = (x1 - x0) // 2 * 2, (y1 - y0) // 2 * 2 out_path = out_dir / f"{path.stem}_locked.mp4" tmp_path = out_dir / f"{path.stem}_locked_raw.mp4" vw = cv2.VideoWriter(str(tmp_path), cv2.VideoWriter_fourcc(*"mp4v"), fps, (cw, ch)) for f in warped: vw.write(f[y0 : y0 + ch, x0 : x0 + cw]) vw.release() warped_grays = [ cv2.cvtColor(f[y0 : y0 + ch, x0 : x0 + cw], cv2.COLOR_BGR2GRAY) for f in warped ] last = cums[-1] report = { "video": path.name, "model": model, "frames": len(frames), "trim_frames": {"start": start_frame, "end": end_frame}, "reference_frame": ref, "source_size": [w, h], "locked_size": [cw, ch], "crop_rect": {"x": x0, "y": y0, "width": cw, "height": ch}, "extra_crop": {"left": cl, "right": cr, "top": ct, "bottom": cb}, "track_roi": track_roi, "crop_loss_ratio": round(1 - (cw * ch) / (w * h), 4), "total_drift_px": { "dx": round(float(last[0, 2]), 1), "dy": round(float(last[1, 2]), 1), }, "total_rotation_deg": round( float(np.degrees(np.arctan2(last[1, 0], last[0, 0]))), 3 ), "total_scale": round(float(np.hypot(last[0, 0], last[1, 0])), 4), "background_residual_px": round(background_residual(warped_grays), 3), } return tmp_path, out_path, report def main(): ap = argparse.ArgumentParser(description=__doc__) ap.add_argument("inputs", nargs="+") ap.add_argument("--model", choices=["similarity", "homography"], default="similarity") ap.add_argument("--out-dir", default=str(Path(__file__).parent / "output")) ap.add_argument("--crop-left", type=int, default=0) ap.add_argument("--crop-right", type=int, default=0) ap.add_argument("--crop-top", type=int, default=0) ap.add_argument("--crop-bottom", type=int, default=0) ap.add_argument("--start-frame", type=int, default=0) ap.add_argument("--end-frame", type=int, default=None) ap.add_argument("--ref-frame", default="0", help="frame index or 'middle'") ap.add_argument( "--track-roi", type=lambda value: tuple(map(int, value.split(","))), help="feature-tracking region as x,y,width,height", ) args = ap.parse_args() extra = (args.crop_left, args.crop_right, args.crop_top, args.crop_bottom) out_dir = Path(args.out_dir) out_dir.mkdir(parents=True, exist_ok=True) reports = [] for p in args.inputs: tmp, out, rep = process(p, out_dir, args.model, extra, args.start_frame, args.end_frame, args.ref_frame, args.track_roi) # re-encode to h264/yuv420p for playability, then drop the mp4v temp import subprocess subprocess.run( ["ffmpeg", "-v", "error", "-y", "-i", str(tmp), "-c:v", "libx264", "-crf", "18", "-pix_fmt", "yuv420p", str(out)], check=True, ) tmp.unlink() reports.append(rep) print(json.dumps(rep, indent=2)) report_path = out_dir / "report.json" existing = json.loads(report_path.read_text()) if report_path.exists() else [] merged = {r["video"]: r for r in existing} merged.update({r["video"]: r for r in reports}) report_path.write_text(json.dumps(list(merged.values()), indent=2)) print(f"\nreport written to {report_path}") if __name__ == "__main__": main()