primocode 10.16.0 → 10.17.1

package/editor/helpers/style_samples.py

@@ -0,0 +1,246 @@
+"""Sample PNGs of every caption and hook style on a real frame of the cut (Contract 7).
+
+Writes edit/samples/caption_<id>.png and edit/samples/hook_<id>.png at 540x960 (960x540 for a
+horizontal cut) plus edit/samples/index.json, and points state.json "samples" at the index.
+
+The speaker's face is found on the frame (face_layout.py, YuNet) and each sample goes to the free
+spot closest to its usual height, off the face, the way compose_final.py places the real text.
+Without --time, when the frame at 25% shows no speaker (a screen, a product), the frame moves to the
+middle of the nearest cut segment with a face (face_layout.json, which compose_final.py reuses); a
+frame where the detector misses the face uses its segment's face zone. A
+number in edit_data.json (hook.center_y, captions.center_y) is used as it is. index.json also
+gets "face" (the zone found, fractions of the frame, or null), "positions" ({"caption": {id: px},
+"hook": {id: px}} on the full-size canvas) and "suggest" ({"camera_focus_y": eyes line or null}).
+
+Usage:
+    uv run python helpers/style_samples.py --edit-dir DIR [--time T] [--accent HEX] [--text "..."]
+        [--hook-text "..."] [--video other.mp4]
+"""
+
+from __future__ import annotations
+
+import argparse
+import subprocess
+import sys
+import tempfile
+import time
+from pathlib import Path
+
+from PIL import Image
+
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+from common import hex_to_rgb, load_json, load_style_catalog, now_iso, probe_video, require_binary, save_json  # noqa: E402
+import face_layout  # noqa: E402
+import text_render as tr  # noqa: E402
+
+DEFAULT_CAPTION_TEXT = "Olha só isso aqui"
+DEFAULT_HOOK_TEXT = "Você está perdendo venda assim"
+
+
+def grab_frame(video: Path, t: float) -> Image.Image:
+    with tempfile.TemporaryDirectory(prefix="samples-") as tmp:
+        out = Path(tmp) / "frame.png"
+        cmd = ["ffmpeg", "-v", "error", "-y", "-ss", f"{max(0.0, t):.3f}", "-i", str(video), "-frames:v", "1", str(out)]
+        proc = subprocess.run(cmd, capture_output=True, text=True)
+        if proc.returncode != 0 or not out.exists():
+            # seeking past the last frame gives nothing: fall back to the first frame
+            cmd[5] = "0"
+            proc = subprocess.run(cmd, capture_output=True, text=True)
+        if not out.exists():
+            raise RuntimeError(f"não consegui extrair um quadro de {video}: {proc.stderr[-400:]}")
+        with Image.open(out) as im:
+            return im.convert("RGB")
+
+
+def caption_text_near(captions: dict | None, t: float) -> str | None:
+    """A real cue around time t (prefers cues with 2+ words)."""
+    if not captions:
+        return None
+    cues = [c for c in captions.get("cues", []) if c.get("words")]
+    if not cues:
+        return None
+    multi = [c for c in cues if len(c["words"]) >= 2] or cues
+    best = min(multi, key=lambda c: abs((c["start"] + c["end"]) / 2.0 - t))
+    return " ".join(w["text"] for w in best["words"])
+
+
+def _load_dict(path: Path, notes: list[str]) -> dict:
+    """A JSON object from the edit dir, or {} (with a note) when it is missing or unreadable."""
+    try:
+        data = load_json(path)
+    except (ValueError, OSError) as e:
+        notes.append(f"ignorei {path.name}: não consegui ler ({e})")
+        return {}
+    return data if isinstance(data, dict) else {}
+
+
+def _manual(sec: dict, key: str) -> float | None:
+    v = sec.get(key) if isinstance(sec, dict) else None
+    if v is None or (isinstance(v, str) and v.strip().lower() == "auto"):
+        return None
+    try:
+        return float(v)
+    except (TypeError, ValueError):
+        return None
+
+
+def free_spot(img, pref: float, faces: list[tuple[float, float]], lay: dict) -> float:
+    """Center for a text drawn at `pref` in `img` (ink box measured) that clears the faces."""
+    bb = tr.ink_bbox(img)
+    if not bb:
+        return pref
+    c = face_layout.free_center(pref, pref - bb[1], bb[3] - pref, faces, lay["top"], lay["bottom"])
+    return pref if c is None else c
+
+
+def main(argv: list[str] | None = None) -> int:
+    ap = argparse.ArgumentParser(description="Gera amostras de todos os estilos de legenda e gancho sobre um quadro do corte.")
+    ap.add_argument("--edit-dir", required=True, help="pasta edit/ da sessão")
+    ap.add_argument("--time", type=float, help="segundo do quadro (padrão: 25%% do vídeo)")
+    ap.add_argument("--accent", help="cor de destaque em hex (padrão: a do edit_data, do preview ou do catálogo)")
+    ap.add_argument("--text", help="texto das amostras (legenda e gancho)")
+    ap.add_argument("--hook-text", help="texto só do gancho (padrão: --text, o gancho do edit_data ou um exemplo)")
+    ap.add_argument("--video", help="vídeo de onde tirar o quadro (padrão: edit/cut.mp4)")
+    args = ap.parse_args(argv)
+
+    require_binary("ffmpeg")
+    edit = Path(args.edit_dir).resolve()
+    if not edit.is_dir():
+        print(f"erro: pasta de edição não encontrada: {edit}", file=sys.stderr)
+        return 2
+    video = Path(args.video).resolve() if args.video else edit / "cut.mp4"
+    if not video.exists():
+        print(f"erro: vídeo não encontrado: {video}. Renderize o corte primeiro (render_cut.py) ou passe --video.",
+              file=sys.stderr)
+        return 2
+
+    catalog = load_style_catalog()
+    notes = []
+    edit_data = _load_dict(edit / "edit_data.json", notes)
+    picks = _load_dict(edit / "preview_style.json", notes)
+    captions = _load_dict(edit / "captions.json", notes) or None
+
+    accent = args.accent or edit_data.get("accent") or picks.get("accent") \
+        or (catalog.get("defaults") or {}).get("accent") or tr.DEFAULT_ACCENT
+    try:
+        hex_to_rgb(accent)
+    except ValueError:
+        print(f"erro: cor inválida: {accent!r} (use algo como #FFC400)", file=sys.stderr)
+        return 2
+
+    info = probe_video(video)
+    duration = float(info.get("duration") or 0.0)
+    t = args.time if args.time is not None else duration * 0.25
+    if duration > 0:
+        t = min(max(0.0, t), max(0.0, duration - 0.05))
+    layout_seg = None
+    if video == edit / "cut.mp4":
+        # the face of each cut segment (face_layout.json, cached for compose_final): the default frame
+        # is moved to the nearest segment where the speaker shows up
+        try:
+            segs = [s for s in face_layout.build(edit).get("segments") or [] if isinstance(s, dict)]
+        except Exception as e:  # noqa: BLE001  (samples still work without the face)
+            segs = []
+            notes.append(f"não consegui procurar o rosto no corte ({e})")
+        here = next((s for s in segs if s["start"] <= t < s["end"]), None)
+        with_face = [s for s in segs if s.get("face")]
+        if args.time is None and with_face and not (here and here.get("face")):
+            here = min(with_face, key=lambda s: min(abs(t - s["start"]), abs(t - s["end"])))
+            t = round((here["start"] + here["end"]) / 2.0, 3)
+        layout_seg = here if here and here.get("face") else None
+
+    caption_text = args.text or caption_text_near(captions, t) or DEFAULT_CAPTION_TEXT
+    hook_text = args.hook_text or args.text or (edit_data.get("hook") if isinstance(edit_data.get("hook"), dict) else {}).get("text") \
+        or picks.get("hook_text") or DEFAULT_HOOK_TEXT
+
+    started = time.time()
+    frame = grab_frame(video, t)
+    vertical = frame.height >= frame.width
+    size = (540, 960) if vertical else (960, 540)
+    # compose on the full-size canvas, then shrink: sharper than drawing at 540 wide
+    background = tr.cover_image(frame, (1080, 1920) if vertical else (1920, 1080))
+
+    samples = edit / "samples"
+    samples.mkdir(parents=True, exist_ok=True)
+    cap_ids = [s["id"] for s in catalog.get("caption_styles", [])] or tr.caption_style_ids()
+    hook_ids = [s["id"] for s in catalog.get("hook_styles", [])] or tr.hook_style_ids()
+
+    canvas = tr.sample_canvas(background.size)
+    lay = tr.layout_defaults(canvas)
+    face = zone = None
+    try:
+        face = face_layout.detect_image(background)
+    except Exception as e:  # noqa: BLE001  (samples still work without the face)
+        notes.append(f"não consegui procurar o rosto ({e}); amostras nas alturas padrão")
+    faces: list[tuple[float, float]] = []
+    if not face and layout_seg is not None:
+        face = layout_seg["face"]       # not found on this very frame: the segment's face
+    if face:
+        _, zone, _ = face_layout._summarize([face])
+        if layout_seg is not None and face is layout_seg["face"] and layout_seg.get("zone"):
+            zone = layout_seg["zone"]
+        gap = face_layout.GAP_FRAC * canvas[1]
+        faces = [(zone["y0"] * canvas[1] - gap, zone["y1"] * canvas[1] + gap)]
+    manual = {"caption": _manual(edit_data.get("captions"), "center_y"), "hook": _manual(edit_data.get("hook"), "center_y")}
+    out_cfg = edit_data.get("output") if isinstance(edit_data.get("output"), dict) else {}
+    try:
+        scale_y = canvas[1] / float(out_cfg.get("height") or canvas[1])
+    except (TypeError, ValueError, ZeroDivisionError):
+        scale_y = 1.0
+
+    def position(kind: str, sid: str, text: str) -> float:
+        if manual[kind] is not None:
+            return manual[kind] * scale_y
+        if kind == "caption":
+            words, active = tr.sample_caption_words(text, sid)
+            probe = tr.render_caption_image(words, sid, accent, canvas, active=active, center_y=lay["caption"])
+            return free_spot(probe, lay["caption"], faces, lay) if faces else lay["caption"]
+        probe = tr.render_hook(text, sid, accent, canvas, center_y=int(round(lay["hook"])))
+        return free_spot(probe, lay["hook"], faces, lay) if faces else lay["hook"]
+
+    index = {"frame_time": round(t, 3), "accent": accent, "caption": {}, "hook": {},
+             "caption_text": caption_text, "hook_text": hook_text, "size": list(size),
+             "face": zone, "positions": {"caption": {}, "hook": {}},
+             "suggest": {"camera_focus_y": round(face["eyes_y"], 3) if face else None},
+             "created_at": now_iso()}
+    skipped = []
+    for kind, ids, text in (("caption", cap_ids, caption_text), ("hook", hook_ids, hook_text)):
+        for sid in ids:
+            try:
+                cy = position(kind, sid, text)
+                img = tr.render_sample_frame(background, kind, sid, accent, text, center_y=cy).resize(size, Image.LANCZOS)
+            except ValueError as e:
+                skipped.append(f"{kind} {sid}: {e}")
+                continue
+            index["positions"][kind][sid] = int(round(cy))
+            name = f"{kind}_{sid}.png"
+            tmp = samples / f".tmp-{name}"
+            img.save(tmp, "PNG", optimize=False, compress_level=6)
+            tmp.replace(samples / name)
+            index[kind][sid] = name
+    save_json(samples / "index.json", index)
+
+    state_path = edit / "state.json"
+    state = load_json(state_path, default={}) or {}
+    state["samples"] = "samples/index.json"
+    state["updated_at"] = now_iso()
+    save_json(state_path, state)
+
+    for msg in skipped:
+        print(f"aviso: estilo ignorado ({msg})", file=sys.stderr)
+    for msg in notes + tr.text_issues("hook", hook_text, hook_ids[0] if hook_ids else "manchete"):
+        print(f"aviso: {msg}", file=sys.stderr)
+    where = ""
+    if face:
+        caps = sorted(set(index["positions"]["caption"].values()))
+        hooks = sorted(set(index["positions"]["hook"].values()))
+        span = lambda v: f"{v[0]}" if len(v) == 1 else f"{v[0]} a {v[-1]}"  # noqa: E731
+        where = (f", rosto em {zone['y0']:.2f}-{zone['y1']:.2f} da altura: legenda em {span(caps)} px, "
+                 f"gancho em {span(hooks)} px, camera.focus_y sugerido {index['suggest']['camera_focus_y']}")
+    print(f"ok: {len(index['caption'])} amostras de legenda e {len(index['hook'])} de gancho "
+          f"(quadro em {t:.2f}s, cor {accent}, {time.time() - started:.1f}s{where}) -> {samples / 'index.json'}")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())