横屏视频转竖屏不只是裁一刀：智能 reframe 与主体跟踪裁切

import cv2
import numpy as np


class SubjectLocator:
    def __init__(self):
        self.face = cv2.CascadeClassifier(
            cv2.data.haarcascades + 'haarcascade_frontalface_default.xml')
        self.prev_gray = None

    def locate(self, frame) -> tuple:
        """返回 (主体中心 x 归一化坐标 0~1, 置信度 0~1)"""
        h, w = frame.shape[:2]
        gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)

        # 1. 人脸
        faces = self.face.detectMultiScale(gray, 1.1, 5, minSize=(40, 40))
        if len(faces):
            # 取最大的人脸
            x, y, fw, fh = max(faces, key=lambda f: f[2] * f[3])
            return (x + fw / 2) / w, 0.9

        # 2. 运动（帧差）
        small = cv2.resize(gray, (96, 54))
        if self.prev_gray is not None:
            diff = cv2.absdiff(small, self.prev_gray)
            _, thresh = cv2.threshold(diff, 25, 255, cv2.THRESH_BINARY)
            m = cv2.moments(thresh)
            if m['m00'] > 500:                # 有足够的运动量
                cx = m['m10'] / m['m00']
                self.prev_gray = small
                return cx / 96, 0.5

        self.prev_gray = small
        # 3. 兜底：画面中心（低置信度）
        return 0.5, 0.2

class Smoother:
    def __init__(self, alpha=0.05):
        self.value = 0.5
        self.alpha = alpha          # 越小越平滑（越迟钝）

    def update(self, target, confidence):
        # 置信度越高，跟得越紧
        a = self.alpha * confidence
        self.value = self.value * (1 - a) + target * a
        return self.value

DEADZONE = 0.04          # 归一化坐标，约画面宽度的 4%

def update_with_deadzone(current, target, conf):
    if abs(target - current) < DEADZONE:
        return current            # 不动
    return current + (target - current) * 0.05 * conf

MAX_SPEED = 0.02          # 每帧最多移动画面宽度的 2%

def limit_speed(current, target):
    delta = target - current
    if abs(delta) > MAX_SPEED:
        delta = MAX_SPEED if delta > 0 else -MAX_SPEED
    return current + delta

ffmpeg -i in.mp4 -vf "crop=607:1080:650:0,scale=1080:1920" out.mp4

# crop.cmd
0       crop x 650;
5.2     crop x 700;
12.8    crop x 480;
30.4    crop x 650;

ffmpeg -i in.mp4 \
  -vf "sendcmd=f=crop.cmd,crop=w=607:h=1080:y=0,scale=1080:1920" \
  -c:v libx264 -crf 20 out.mp4

def write_crop_commands(track, out_path, epsilon=0.02):
    """把轨迹转成 sendcmd 文件（只在变化超过阈值时写一条，减少命令数量）。"""
    lines = []
    last_x = None
    for t, x_norm in track:
        x_px = int(x_norm * SRC_W - CROP_W / 2)
        x_px = max(0, min(x_px, SRC_W - CROP_W))
        if last_x is None or abs(x_px - last_x) > epsilon * SRC_W:
            lines.append(f'{t:.3f}\tcrop x {x_px};')
            last_x = x_px
    Path(out_path).write_text('\n'.join(lines), encoding='utf-8')

源文件：1920×1080（横屏）
竖版目标：1080×1920

裁切：608×1080（宽度只用了 1/3）
放大到 1080×1920 = 约 1.78 倍升采样

结果：有效分辨率只有 608×1080，被拉伸到 1080×1920

# y 位置：让主体的脸落在画面上部 1/3 处
crop_y = max(0, int(face_y - CROP_H / 3))

import subprocess
from pathlib import Path

import cv2
import numpy as np


class Reframer:
    def __init__(self, src_w, src_h, dst_w=1080, dst_h=1920, fps=30):
        self.src_w, self.src_h = src_w, src_h
        self.dst_w, self.dst_h = dst_w, dst_h
        self.fps = fps
        # 裁切窗口：保持源的高度，宽度按目标比例
        self.crop_h = src_h
        self.crop_w = int(src_h * dst_w / dst_h)
        self.crop_w -= self.crop_w % 2
        self.locator = SubjectLocator()
        self.smoother = Smoother(alpha=0.05)
        self.value = 0.5

    def analyze(self, video_path, sample_fps=5):
        """按采样率分析每帧的主体位置，返回 [(时间, 归一化x)]。"""
        cap = cv2.VideoCapture(video_path)
        src_fps = cap.get(cv2.CAP_PROP_FPS) or self.fps
        step = max(1, int(round(src_fps / sample_fps)))

        track = []
        idx = 0
        while True:
            ok, frame = cap.read()
            if not ok:
                break
            if idx % step == 0:
                x, conf = self.locator.locate(frame)
                self.value = self.smoother.update(x, conf)
                self.value = limit_speed(self.value, x)
                # 裁切窗口的合法范围
                lo = self.crop_w / 2 / self.src_w
                hi = 1 - self.crop_w / 2 / self.src_w
                track.append((idx / src_fps, float(np.clip(self.value, lo, hi))))
            idx += 1
        cap.release()
        return track

    def render(self, video_path, track, out_path, crf=20):
        cmd_file = str(Path(out_path).with_suffix('.cropcmd'))
        write_crop_commands(track, cmd_file, src_w=self.src_w, crop_w=self.crop_w)

        vf = (f"sendcmd=f={cmd_file},crop=w={self.crop_w}:h={self.crop_h}:y=0,"
              f"scale={self.dst_w}:{self.dst_h}:flags=lanczos")
        cmd = ['ffmpeg', '-y', '-v', 'error', '-i', video_path,
               '-vf', vf, '-c:v', 'libx264', '-crf', str(crf), '-preset', 'slow',
               '-c:a', 'aac', '-b:a', '128k', '-movflags', '+faststart', out_path]
        subprocess.run(cmd, check=True)
        Path(cmd_file).unlink(missing_ok=True)
        return out_path


def write_crop_commands(track, out_path, src_w, crop_w, epsilon=0.02):
    lines = []
    last = None
    for t, x_norm in track:
        x_px = int(x_norm * src_w - crop_w / 2)
        x_px = max(0, min(x_px, src_w - crop_w))
        if last is None or abs(x_px - last) > epsilon * src_w:
            lines.append(f'{t:.3f}\tcrop x {x_px};')
            last = x_px
    Path(out_path).write_text('\n'.join(lines), encoding='utf-8')


def limit_speed(current, target, max_speed=0.02):
    delta = target - current
    if abs(delta) > max_speed:
        delta = max_speed if delta > 0 else -max_speed
    return current + delta


if __name__ == '__main__':
    import sys
    src, out = sys.argv[1], sys.argv[2]
    r = Reframer(1920, 1080)
    t = r.analyze(src)
    r.render(src, t, out)
    print(f'完成：{out}（轨迹点 {len(t)} 个）')