primocode 10.12.0 → 10.14.0

package/lib/estudio/dados/projetos-ae/letra-nos-apps/camera/mesa_2d.py

@@ -0,0 +1,64 @@
+"""Mede o movimento 2D (semelhança: zoom, giro, translação) da MESA nas cenas do jornal.
+Achado: a mesa do autor é uma camada 2D (retângulo alinhado à tela em 16,54 s), filha dos nulls de câmera;
+só o jornal gira em 3D. Fluxo óptico (DIS) entre quadros vizinhos só na madeira (fora do quadrilátero das
+páginas, que vem da câmera 3D), semelhança por RANSAC, encadeada a partir do quadro de referência.
+Saída: camera/mesa2d-<X>.json {ref, quadros: [{f, t, S: 3x3 (tela no ref -> tela no quadro), area}]}
+Uso: python -I mesa_2d.py F|J '<json do quadrilátero das páginas no plano>'"""
+import json, sys, cv2, numpy as np
+CENA = sys.argv[1]; PAG = np.array(json.loads(sys.argv[2]), float)
+VID = "<SUA_CENTRAL>/05-pesquisa/referencias/2026-10-17-subzmotion/midia/05-DeMZpQ5gv-t.mp4"
+d = json.load(open(f"camera3d-{CENA}.json")); Q = {q["f"]: q for q in d["quadros"]}
+REF = {"F": 394, "J": 670}[CENA]
+K = np.array([[1500, 0, 540], [0, 1500, 540], [0, 0, 1.0]])
+fs = sorted(Q)
+cap = cv2.VideoCapture(VID); cap.set(cv2.CAP_PROP_POS_FRAMES, fs[0]); G = {}
+for f in fs:
+    ok, im = cap.read(); G[f] = cv2.cvtColor(im, cv2.COLOR_BGR2GRAY)
+def mask(f):
+    R = np.array(Q[f]["R"]); t = np.array(Q[f]["tc"]); Hp = K @ np.c_[R[:, 0], R[:, 1], t]
+    P = np.c_[PAG, np.ones(4)] @ Hp.T; ok = (P[:, 2] > 0).all()
+    m = np.full((1080, 1080), 255, np.uint8)
+    if ok:
+        P = P[:, :2] / P[:, 2:3]; cv2.fillPoly(m, [np.clip(P, -1e5, 1e5).astype(np.int32)], 0)
+    else:
+        m[:] = 0
+    m = cv2.erode(m, np.ones((31, 31), np.uint8))
+    m[:30] = 0; m[-30:] = 0; m[:, :30] = 0; m[:, -30:] = 0
+    # fora da mesa (fundo escuro do fim) também sai
+    m[G[f] < 25] = 0
+    return m
+dis = cv2.DISOpticalFlow_create(cv2.DISOPTICAL_FLOW_PRESET_MEDIUM)
+def sim(a, b):
+    """semelhança tela a -> tela b medida na madeira visível nos dois"""
+    ma = mask(a); mb = mask(b)
+    fl = dis.calc(G[a], G[b], None)
+    ys, xs = np.nonzero(ma[::6, ::6]); ys *= 6; xs *= 6
+    if len(xs) < 300: return None, len(xs)
+    p1 = np.c_[xs, ys].astype(np.float32); p2 = p1 + fl[ys, xs]
+    ok = (p2[:, 0] > 0) & (p2[:, 0] < 1079) & (p2[:, 1] > 0) & (p2[:, 1] < 1079)
+    p1, p2 = p1[ok], p2[ok]
+    keep = mb[p2[:, 1].astype(int), p2[:, 0].astype(int)] > 0
+    p1, p2 = p1[keep], p2[keep]
+    if len(p1) < 300: return None, len(p1)
+    A, inl = cv2.estimateAffinePartial2D(p1, p2, method=cv2.RANSAC, ransacReprojThreshold=2.0)
+    if A is None or inl.sum() < 200: return None, int(len(p1))
+    S = np.eye(3); S[:2] = A; return S, int(inl.sum())
+S = {REF: np.eye(3)}; area = {REF: 1}
+for direc in (-1, 1):
+    f = REF
+    while (f + direc) in Q:
+        g = f + direc
+        T, n = sim(f, g)
+        if T is None: S[g] = None; area[g] = n; f = g; continue
+        base = f
+        while S.get(base) is None: base -= direc
+        S[g] = T @ S[f] if S[f] is not None else None; area[g] = n
+        f = g
+out = []
+for f in fs:
+    s = S.get(f)
+    if s is not None:
+        sc = float(np.sqrt(abs(np.linalg.det(s[:2, :2])))); rot = float(np.degrees(np.arctan2(s[1, 0], s[0, 0])))
+    print(f, round(f / 24, 3), area.get(f), None if s is None else (round(sc, 3), round(rot, 2), np.round(s[:2, 2], 1).tolist()))
+    out.append({"f": f, "t": round(f / 24, 5), "S": None if s is None else s.tolist(), "n": area.get(f)})
+json.dump({"ref": REF, "quadros": out}, open(f"mesa2d-{CENA}.json", "w"))

package/lib/estudio/dados/projetos-ae/letra-nos-apps/camera/plot_cenas.py

@@ -0,0 +1,11 @@
+import json, sys, numpy as np
+import matplotlib; matplotlib.use("Agg"); import matplotlib.pyplot as plt
+d = json.load(open(sys.argv[1])); out = sys.argv[2]
+fig, ax = plt.subplots(4, 1, figsize=(22, 12), sharex=True)
+for k, v in d.items():
+    q = v["quadros"]; t = [x["t"] for x in q]
+    ax[0].plot(t, np.log2([x["s"] for x in q]), label=k); ax[1].plot(t, [x["wx"] for x in q]); ax[2].plot(t, [x["wy"] for x in q]); ax[3].plot(t, [x["rot"] for x in q])
+    for a in ax: a.axvline(v["ini"], color="k", alpha=.3)
+    ax[0].text(v["ini"] + .05, ax[0].get_ylim()[1] if False else 5, k, fontsize=9)
+for a, l in zip(ax, ["log2 zoom (0 = ref)", "mira x (mundo)", "mira y (mundo)", "giro (graus)"]): a.set_ylabel(l); a.grid(alpha=.3)
+ax[3].set_xticks(np.arange(0, 34.1, 1)); plt.tight_layout(); plt.savefig(out, dpi=65)

package/lib/estudio/dados/projetos-ae/letra-nos-apps/camera/retificar_quadros.py

@@ -0,0 +1,38 @@
+"""Desentorta quadros do original para o plano do jornal (coordenadas do mundo da cena) e monta um mosaico,
+ficando em cada ponto o quadro que tem mais resolução ali. Serve para decalcar a diagramação da página.
+Uso: python -I retificar_quadros.py F|J escala saida.png quadro1 quadro2 ...   (escala = px por unidade do plano)"""
+import json, sys, cv2, numpy as np
+CENA, ESC, OUT = sys.argv[1], float(sys.argv[2]), sys.argv[3]
+QS = [int(x) for x in sys.argv[4:]]
+VID = "<SUA_CENTRAL>/05-pesquisa/referencias/2026-10-17-subzmotion/midia/05-DeMZpQ5gv-t.mp4"
+d = json.load(open(f"camera3d-{CENA}.json")); Q = {q["f"]: q for q in d["quadros"]}
+K = np.array([[1500, 0, 540], [0, 1500, 540], [0, 0, 1.0]])
+def Hps(f):
+    R = np.array(Q[f]["R"]); t = np.array(Q[f]["tc"]); return K @ np.c_[R[:, 0], R[:, 1], t]
+# extensão: o maior quadro (mais recuado) define a área
+fl = max(QS, key=lambda f: Q[f]["tc"][2])
+Hi = np.linalg.inv(Hps(fl)); cs = np.array([[0, 0, 1], [1080, 0, 1], [1080, 1080, 1], [0, 1080, 1.0]]) @ Hi.T
+cs = cs[:, :2] / cs[:, 2:3]; x0, y0 = cs.min(0); x1, y1 = cs.max(0)
+if len(sys.argv) > 4 and "--" in sys.argv: pass
+W, Hh = int((x1 - x0) * ESC), int((y1 - y0) * ESC)
+T = np.array([[ESC, 0, -x0 * ESC], [0, ESC, -y0 * ESC], [0, 0, 1.0]])
+cap = cv2.VideoCapture(VID)
+acc = np.zeros((Hh, W, 3), np.float32); best = np.zeros((Hh, W), np.float32)
+for f in sorted(QS):
+    cap.set(cv2.CAP_PROP_POS_FRAMES, f); ok, im = cap.read()
+    M = Hps(f) @ np.linalg.inv(T)  # saída -> tela
+    w = cv2.warpPerspective(im, M, (W, Hh), flags=cv2.INTER_LINEAR | cv2.WARP_INVERSE_MAP)
+    # resolução local: px de tela por unidade do plano ~ f / z_cam
+    yy, xx = np.mgrid[0:Hh, 0:W].astype(np.float32)
+    X = xx / ESC + x0; Y = yy / ESC + y0
+    R = np.array(Q[f]["R"]); t = np.array(Q[f]["tc"])
+    zc = R[2, 0] * X + R[2, 1] * Y + t[2]
+    P = np.stack([X, Y, np.ones_like(X)], -1) @ Hps(f).T; u = P[..., 0] / P[..., 2]; v = P[..., 1] / P[..., 2]
+    dentro = (u > 2) & (u < 1078) & (v > 2) & (v < 1078) & (zc > 0)
+    res = np.where(dentro, 1500 / np.maximum(zc, 1), 0)
+    m = res > best
+    acc[m] = w[m]; best[m] = res[m]
+    print(f, "z", round(t[2]), "px/unidade", round(1500 / t[2], 3))
+cv2.imencode(".png", acc.astype(np.uint8))[1].tofile(OUT)
+json.dump({"x0": float(x0), "y0": float(y0), "escala": ESC, "W": W, "H": Hh}, open(OUT + ".json", "w"))
+print("extensão do plano", round(x0), round(y0), round(x1), round(y1), "->", W, Hh)

package/lib/estudio/dados/projetos-ae/letra-nos-apps/camera/w-agenda/assar_ab.py

@@ -0,0 +1,52 @@
+"""Câmera final das cenas A e B (agente w-agenda, 17/10).
+A: cadeia SIFT de medir_ab.py com 6 passos refeitos por geometria, porque o SIFT falhou neles:
+   - quadros 0->3: anel do checkbox (centro e diâmetro medidos na tela; anel = 18,7 px de mundo);
+   - quadros 28->31: o evento escurece e ganha risco; escala pela altura do chip (69 px de mundo) e
+     translação pelo início do "w" e pelo topo do chip.
+B: cadeia SIFT de medir_ab.py como está (inclusive 4,46–4,83: a câmera NÃO segura, continua recuando).
+Saída: cena-A-agenda.json e cena-B-docs.json no formato do ae/camera.jsx."""
+import json, numpy as np, os
+D = os.path.dirname(os.path.abspath(__file__))
+M = json.load(open(os.path.join(D, "medida-ab.json")))
+def S_de(z, mx, my):
+    s = 2 ** z; T = np.eye(3); T[0, 0] = T[1, 1] = s; T[:2, 2] = [540 - s * mx, 540 - s * my]; return T
+def est(T):
+    s = T[0, 0]; w = np.linalg.inv(T) @ np.array([540, 540, 1.0]); return float(np.log2(s)), float(w[0]), float(w[1])
+def passo(r, tx, ty):
+    T = np.eye(3); T[0, 0] = T[1, 1] = r; T[0, 2] = tx; T[1, 2] = ty; return T
+A = M["A-agenda"]; S = {round(l[0] * 24): S_de(l[1], l[2], l[3]) for l in A}
+# passos medidos por geometria: tela f -> tela f+1
+anel = {0: ((531.5, 548.5), 1158.0), 1: ((449.5, 498.5), 874.0), 2: ((316.0, 414.5), 417.5), 3: ((275.5, 389.0), 274.5)}
+P = {}
+for f in (0, 1, 2):
+    (c0, d0), (c1, d1) = anel[f], anel[f + 1]; r = d1 / d0
+    P[f] = passo(r, c1[0] - r * c0[0], c1[1] - r * c0[1])
+P[28] = passo(382 / 406, 85 - 382 / 406 * 35, 246 - 382 / 406 * 244)
+P[29] = passo(353 / 382, 150 - 353 / 382 * 85, 246 - 353 / 382 * 246)
+P[30] = passo(321 / 353, 225 - 321 / 353 * 150, 246 - 321 / 353 * 246)
+# refaz a cadeia de trás para frente a partir de f31 (bom) e de f3 (refeito)
+for f in (30, 29, 28):
+    S[f] = np.linalg.inv(P[f]) @ S[f + 1]
+# quadros 4..27 dependem da cadeia SIFT ligada ao f28 antigo: aplica a mesma correção relativa
+# (a cadeia SIFT entre 4 e 28 está boa; só o elo 28->31 estava errado)
+Sant28 = S_de(*[l for l in A if round(l[0] * 24) == 28][0][1:4])
+C = np.linalg.inv(Sant28) @ S[28]  # correção no espaço do mundo (as transformações relativas entre quadros ficam iguais)
+for f in range(3, 28):
+    S[f] = S[f] @ C
+for f in (2, 1, 0):
+    S[f] = np.linalg.inv(P[f]) @ S[f + 1]
+def salvar(nome, quadros, ini, fim, ref, pegada):
+    ch = {"zoom": [], "mx": [], "my": [], "giro": []}
+    for f in sorted(quadros):
+        z, mx, my = est(quadros[f]); t = round(f / 24, 4)
+        ch["zoom"].append([t, round(z, 4)]); ch["mx"].append([t, round(mx, 2)]); ch["my"].append([t, round(my, 2)]); ch["giro"].append([t, 0.0])
+    json.dump({"fps": 24, "ini": ini, "fim": fim, "ref": ref, "pegada": pegada, "fonte": "w-agenda/assar_ab.py", "chaves": ch},
+              open(os.path.join(D, "cena-%s.json" % nome), "w"))
+    return ch
+chA = salvar("A-agenda", S, 0.0, 2.62, 2.58, None)
+SB = {round(l[0] * 24): S_de(l[1], l[2], l[3]) for l in M["B-docs"]}
+chB = salvar("B-docs", SB, 2.62, 4.95, 4.875, None)
+for n, ch in (("A", chA), ("B", chB)):
+    print(n)
+    for i in range(0, len(ch["zoom"]), 3):
+        print("  t=%.3f z=%.3f mx=%.1f my=%.1f" % (ch["zoom"][i][0], ch["zoom"][i][1], ch["mx"][i][1], ch["my"][i][1]))

package/lib/estudio/dados/projetos-ae/letra-nos-apps/camera/w-agenda/medir_ab.py

@@ -0,0 +1,59 @@
+"""Remedição da câmera das cenas A e B (agente w-agenda, 17/10).
+Casa cada quadro com o anterior (SIFT + RANSAC, similaridade sem giro), com máscara que tira elementos que se mexem
+sozinhos (cartão voando, globo), e integra a partir do quadro de referência de cada cena.
+Saída: json {cena: [[t, log2 s, mx, my, n_inliers], ...]} no mesmo sentido do camera.jsx (mundo = tela no ref)."""
+import json, sys, cv2, numpy as np
+sys.stdout.reconfigure(encoding="utf-8")
+VID = sys.argv[1]; OUT = sys.argv[2]
+cap = cv2.VideoCapture(VID); Q = []
+while True:
+    ok, q = cap.read()
+    if not ok or len(Q) > 125: break
+    Q.append(cv2.cvtColor(q, cv2.COLOR_BGR2GRAY))
+sift = cv2.SIFT_create(nfeatures=6000, contrastThreshold=0.02)
+bf = cv2.BFMatcher()
+def mascara(f):
+    m = np.full((1080, 1080), 255, np.uint8)
+    t = f / 24.0
+    if 2.19 <= t <= 2.56:   # cartão de detalhes voando (ocupa a metade de baixo): usa só a faixa de cima e a esquerda
+        m[:, :] = 0; m[0:300, :] = 255
+    if 4.40 <= t <= 4.80:   # globo entrando: usa só a faixa do menu/barra
+        m[:, :] = 0; m[0:260, :] = 255
+    return m
+cache = {}
+def kp(f, mf):
+    key = (f, mf)
+    if key not in cache: cache[key] = sift.detectAndCompute(Q[f], mascara(mf))
+    return cache[key]
+def casar(a, b):
+    """transformação tela a -> tela b (similaridade sem giro), usando a máscara do quadro mais crítico"""
+    mf = a if mascara(a).mean() < mascara(b).mean() else b
+    k1, d1 = kp(a, mf); k2, d2 = kp(b, mf)
+    if d1 is None or d2 is None or len(k1) < 8 or len(k2) < 8: return None, 0
+    mm = bf.knnMatch(d1, d2, k=2)
+    bons = [m for m, n in (x for x in mm if len(x) == 2) if m.distance < 0.75 * n.distance]
+    if len(bons) < 8: return None, len(bons)
+    p1 = np.float32([k1[m.queryIdx].pt for m in bons]); p2 = np.float32([k2[m.trainIdx].pt for m in bons])
+    A, inl = cv2.estimateAffinePartial2D(p1, p2, method=cv2.RANSAC, ransacReprojThreshold=3.0, maxIters=5000)
+    if A is None: return None, 0
+    s = float(np.hypot(A[0, 0], A[1, 0])); T = np.eye(3); T[0, 0] = T[1, 1] = s; T[:2, 2] = A[:, 2]
+    # refaz a translação com escala sem giro (média dos inliers)
+    i = inl.ravel().astype(bool)
+    T[:2, 2] = (p2[i] - s * p1[i]).mean(0)
+    return T, int(i.sum())
+res = {}
+for nome, ini, fim, ref in (("A-agenda", 0, 63, 62), ("B-docs", 63, 119, 117)):
+    S = {ref: np.eye(3)}; N = {ref: 999}
+    for f in range(ref + 1, fim + 1):
+        T, n = casar(f - 1, f); S[f] = (T if T is not None else np.eye(3)) @ S[f - 1]; N[f] = n
+    for f in range(ref - 1, ini - 1, -1):
+        T, n = casar(f, f + 1); S[f] = np.linalg.inv(T if T is not None else np.eye(3)) @ S[f + 1]; N[f] = n
+    lin = []
+    for f in range(ini, fim + 1):
+        s = S[f][0, 0]; w = np.linalg.inv(S[f]) @ np.array([540, 540, 1.0])
+        lin.append([round(f / 24, 4), round(float(np.log2(s)), 4), round(float(w[0]), 2), round(float(w[1]), 2), N[f]])
+    res[nome] = lin
+json.dump(res, open(OUT, "w"))
+for k, v in res.items():
+    print(k)
+    for l in v: print("  t=%.3f z=%.3f mx=%.1f my=%.1f n=%s" % tuple(l))

package/lib/estudio/dados/projetos-ae/letra-nos-apps/camera/wg_ajustar_h.py

@@ -0,0 +1,111 @@
+# Câmera por homografia: para cada quadro, H (mundo -> tela) casando com quadros âncora (SIFT), direto ou em cadeia.
+# Decompõe H = P ∘ S: S = similaridade local no centro da tela (zoom, mira, giro -> controles do CAM)
+#                    P = resto projetivo em tela (vira Corner Pin), guardado como deslocamento dos 4 cantos
+#                        do quadro ampliado [-M, 1080+M] (M = margem do comp interno).
+# uso: python ajustar_h.py <id> <saida.json> --ancora t [t ...] [--de t0] [--ate t1] [--margem 270] [--sem-ref]
+import sys, json, math, cv2, numpy as np
+P = "<SUA_CENTRAL>/07-videos/projetos/2026-10-17-subzmotion-recriacao/"
+ORIG = "<SUA_CENTRAL>/05-pesquisa/referencias/2026-10-17-subzmotion/midia/05-DeMZpQ5gv-t.mp4"
+a = sys.argv; cid = a[1]; out = a[2]
+d = json.load(open(P + "camera/cena-%s.json" % cid, encoding="utf-8")); ch = d["chaves"]
+def lista(flag):
+    if flag not in a: return []
+    i = a.index(flag) + 1; r = []
+    while i < len(a) and not a[i].startswith("--"): r.append(float(a[i])); i += 1
+    return r
+ancoras = lista("--ancora") or [d["ref"]]
+t0 = lista("--de")[0] if "--de" in a else d["ini"]; t1 = lista("--ate")[0] if "--ate" in a else d["fim"]
+MG = lista("--margem")[0] if "--margem" in a else 270.0
+def interp(lst, t):
+    ts = [x for x, y in lst]
+    if t <= ts[0]: return lst[0][1]
+    if t >= ts[-1]: return lst[-1][1]
+    for i in range(1, len(ts)):
+        if ts[i] >= t:
+            u = (t - ts[i-1]) / (ts[i] - ts[i-1]); return lst[i-1][1] * (1-u) + lst[i][1] * u
+def json_cam(t): return [interp(ch[n], t) for n in ("zoom", "mx", "my", "giro")]
+def S_de(z, mx, my, g):
+    s = 2 ** z; r = math.radians(g); A = s * np.array([[math.cos(r), -math.sin(r)], [math.sin(r), math.cos(r)]])
+    T = np.eye(3); T[:2, :2] = A; T[:2, 2] = np.array([540, 540]) - A @ np.array([mx, my]); return T
+CANT = np.float32([[-MG, -MG], [1080 + MG, -MG], [-MG, 1080 + MG], [1080 + MG, 1080 + MG]])
+def decompor(H):
+    H = H / H[2, 2]
+    c = np.linalg.inv(H) @ np.array([540, 540, 1.0]); w = c[:2] / c[2]
+    def Hp(x, y):
+        v = H @ np.array([x, y, 1.0]); return v[:2] / v[2]
+    e = 0.5; J = np.column_stack([(Hp(w[0] + e, w[1]) - Hp(w[0] - e, w[1])) / (2 * e), (Hp(w[0], w[1] + e) - Hp(w[0], w[1] - e)) / (2 * e)])
+    s = math.sqrt(abs(np.linalg.det(J))); g = math.degrees(math.atan2(J[1, 0] - J[0, 1], J[0, 0] + J[1, 1]))
+    S = S_de(math.log2(s), w[0], w[1], g)
+    Pm = H @ np.linalg.inv(S); Pm /= Pm[2, 2]
+    cp = cv2.perspectiveTransform(CANT[None], Pm)[0] - CANT
+    return [math.log2(s), float(w[0]), float(w[1]), g], cp.ravel().tolist()
+def compor(cam, cp):
+    S = S_de(*cam); dst = (CANT + np.float32(cp).reshape(4, 2)).astype(np.float32)
+    Pm = cv2.getPerspectiveTransform(CANT, dst); return Pm @ S
+cap = cv2.VideoCapture(ORIG); cache = {}
+sift = cv2.SIFT_create(6000); bf = cv2.BFMatcher()
+def quadro(f):
+    if f not in cache:
+        cap.set(cv2.CAP_PROP_POS_FRAMES, f); ok, q = cap.read(); g = cv2.cvtColor(q, cv2.COLOR_BGR2GRAY)
+        cache[f] = sift.detectAndCompute(g, None)
+    return cache[f]
+def homog(fa, fb):
+    k1, d1 = quadro(fa); k2, d2 = quadro(fb)
+    if d1 is None or d2 is None or len(k1) < 15 or len(k2) < 15: return None, 0
+    mm = bf.knnMatch(d1, d2, k=2); b = [m for m, n in (x for x in mm if len(x) == 2) if m.distance < 0.75 * n.distance]
+    if len(b) < 20: return None, 0
+    p1 = np.float32([k1[m.queryIdx].pt for m in b]); p2 = np.float32([k2[m.trainIdx].pt for m in b])
+    H, inl = cv2.findHomography(p1, p2, cv2.RANSAC, 3.0)
+    if H is None: return None, 0
+    n = int(inl.sum())
+    if n < 25 or n / len(b) < 0.3: return None, n
+    q = p2[inl.ravel() > 0]
+    if q[:, 0].std() < 50 or q[:, 1].std() < 50: return None, n
+    return H, n
+f0 = int(math.ceil(t0 * 24 - 1e-6)); f1 = int(math.floor(t1 * 24 + 1e-6))
+fa = [int(round(t * 24)) for t in ancoras]
+sol = {}
+for f in fa: sol[f] = (S_de(*json_cam(f / 24.0)), "ancora", 9999)
+def plausivel(H, prev):
+    cam, cp = decompor(H)
+    if prev is None: return True
+    pc, pp = decompor(prev)
+    if abs(cam[0] - pc[0]) > 0.6 or math.hypot(cam[1] - pc[1], cam[2] - pc[2]) * 2 ** cam[0] > 500: return False
+    if max(abs(v) for v in cp) > 1500: return False
+    return True
+ordem = sorted(fa)
+for i, A in enumerate(ordem):
+    esq = (ordem[i-1] + A) // 2 if i > 0 else f0 - 1
+    dir_ = (A + ordem[i+1]) // 2 if i + 1 < len(ordem) else f1 + 1
+    for passo, lim in ((-1, esq), (1, dir_)):
+        viz = A; f = A + passo
+        while (f > lim if passo < 0 else f < lim):
+            melhor = None
+            H, n = homog(A, f)
+            if H is not None and plausivel(H @ sol[A][0], sol[viz][0]):
+                melhor = (H @ sol[A][0], "direto %.2f" % (A / 24.0), n)
+            else:
+                H2, n2 = homog(viz, f)
+                if H2 is not None and plausivel(H2 @ sol[viz][0], sol[viz][0]):
+                    melhor = (H2 @ sol[viz][0], "cadeia", n2)
+            if melhor:
+                sol[f] = melhor; viz = f
+            f += passo
+ok = sorted(k for k in sol if f0 <= k <= f1)
+dec = {k: decompor(sol[k][0]) for k in ok}
+corr = {k: [dec[k][0][j] - json_cam(k / 24.0)[j] for j in range(4)] for k in ok}
+linhas = []
+for f in range(f0, f1 + 1):
+    jc = json_cam(f / 24.0)
+    if f in dec:
+        cam, cp = dec[f]; met = sol[f][1]
+    elif ok:
+        c = [float(np.interp(f, ok, [corr[k][j] for k in ok])) for j in range(4)]
+        cam = [jc[j] + c[j] for j in range(4)]
+        cp = [float(np.interp(f, ok, [dec[k][1][j] for k in ok])) for j in range(8)]; met = "buraco"
+    else:
+        cam, cp, met = jc, [0.0] * 8, "json"
+    linhas.append({"t": round(f / 24.0, 4), "zoom": cam[0], "mx": cam[1], "my": cam[2], "giro": cam[3], "cp": cp, "met": met})
+    print("%.3f %-12s z%6.3f M(%7.1f,%7.1f) g%6.2f | pin max %5.1f | json z%6.3f M(%7.1f,%7.1f) g%6.2f" % (
+        f / 24.0, met, cam[0], cam[1], cam[2], cam[3], max(abs(v) for v in cp), jc[0], jc[1], jc[2], jc[3]))
+json.dump({"cena": cid, "ancoras": ancoras, "margem": MG, "quadros": linhas}, open(out, "w"), indent=0)

package/lib/estudio/dados/projetos-ae/letra-nos-apps/camera/wg_corrige_cam.py

@@ -0,0 +1,17 @@
+"""Correção manual (conferida no quadro do original) somada a um canal da câmera ajustada.
+uso: python camera/wg_corrige_cam.py <id> <canal: zoom|mx|my|giro> t:delta [t:delta ...]
+Os deltas são interpolados linearmente entre os tempos dados e valem 0 fora do intervalo.
+Grava um histórico em "correcoes" dentro do JSON (para saber o que foi mexido à mão)."""
+import sys, json, numpy as np
+P = "<SUA_CENTRAL>/07-videos/projetos/2026-10-17-subzmotion-recriacao/"
+cid, canal = sys.argv[1], sys.argv[2]
+pts = sorted([tuple(float(v) for v in a.split(":")) for a in sys.argv[3:]])
+arq = P + "camera/cena-%s-ajustada.json" % cid
+d = json.load(open(arq))
+ts = [p[0] for p in pts]; vs = [p[1] for p in pts]
+for k in d["chaves"][canal]:
+    t = k[0]
+    if ts[0] <= t <= ts[-1]: k[1] = round(k[1] + float(np.interp(t, ts, vs)), 4)
+d.setdefault("correcoes", []).append({"canal": canal, "pontos": pts})
+json.dump(d, open(arq, "w"))
+print("ok", cid, canal, pts)

package/lib/estudio/dados/projetos-ae/letra-nos-apps/camera/wg_ecc_cadeia.py

@@ -0,0 +1,80 @@
+# Câmera por cadeia ECC quadro a quadro (para cenas de pouca textura, ex.: K-maps).
+# uso: python ecc_cadeia.py <id> <saida.json> <t_ancora> [--de t0] [--ate t1] [--margem 270] [--modelo affine|homog]
+# A âncora usa a câmera json; cada passo alinha o quadro f com f±1 (ECC multiescala) começando pelo movimento do json.
+import sys, json, math, cv2, numpy as np
+P = "<SUA_CENTRAL>/07-videos/projetos/2026-10-17-subzmotion-recriacao/"
+ORIG = "<SUA_CENTRAL>/05-pesquisa/referencias/2026-10-17-subzmotion/midia/05-DeMZpQ5gv-t.mp4"
+a = sys.argv; cid = a[1]; out = a[2]; tanc = float(a[3])
+d = json.load(open(P + "camera/cena-%s.json" % cid, encoding="utf-8")); ch = d["chaves"]
+def opt(flag, dflt):
+    return a[a.index(flag) + 1] if flag in a else dflt
+t0 = float(opt("--de", d["ini"])); t1 = float(opt("--ate", d["fim"])); MG = float(opt("--margem", 270)); modelo = opt("--modelo", "homog")
+def interp(lst, t):
+    ts = [x for x, y in lst]
+    if t <= ts[0]: return lst[0][1]
+    if t >= ts[-1]: return lst[-1][1]
+    for i in range(1, len(ts)):
+        if ts[i] >= t:
+            u = (t - ts[i-1]) / (ts[i] - ts[i-1]); return lst[i-1][1] * (1-u) + lst[i][1] * u
+def json_cam(t): return [interp(ch[n], t) for n in ("zoom", "mx", "my", "giro")]
+def S_de(z, mx, my, g):
+    s = 2 ** z; r = math.radians(g); A = s * np.array([[math.cos(r), -math.sin(r)], [math.sin(r), math.cos(r)]])
+    T = np.eye(3); T[:2, :2] = A; T[:2, 2] = np.array([540, 540]) - A @ np.array([mx, my]); return T
+CANT = np.float32([[-MG, -MG], [1080 + MG, -MG], [-MG, 1080 + MG], [1080 + MG, 1080 + MG]])
+def decompor(H):
+    H = H / H[2, 2]; c = np.linalg.inv(H) @ np.array([540, 540, 1.0]); w = c[:2] / c[2]
+    def Hp(x, y):
+        v = H @ np.array([x, y, 1.0]); return v[:2] / v[2]
+    e = 0.5; J = np.column_stack([(Hp(w[0] + e, w[1]) - Hp(w[0] - e, w[1])) / (2 * e), (Hp(w[0], w[1] + e) - Hp(w[0], w[1] - e)) / (2 * e)])
+    s = math.sqrt(abs(np.linalg.det(J))); g = math.degrees(math.atan2(J[1, 0] - J[0, 1], J[0, 0] + J[1, 1]))
+    S = S_de(math.log2(s), w[0], w[1], g); Pm = H @ np.linalg.inv(S); Pm /= Pm[2, 2]
+    cp = cv2.perspectiveTransform(CANT[None], Pm)[0] - CANT
+    return [math.log2(s), float(w[0]), float(w[1]), g], cp.ravel().tolist()
+cap = cv2.VideoCapture(ORIG); cache = {}
+def quadro(f):
+    if f not in cache:
+        cap.set(cv2.CAP_PROP_POS_FRAMES, f); ok, q = cap.read(); cache[f] = cv2.cvtColor(q, cv2.COLOR_BGR2GRAY).astype(np.float32) / 255.0
+    return cache[f]
+def ecc(fa, fb, H0):
+    """H tela(fa)->tela(fb). ECC acha W com  I_b(W x) ~ I_a(x)?  Usamos template = fb, input = fa: W leva coords de fb -> fa."""
+    A = quadro(fa); B = quadro(fb)
+    W = np.linalg.inv(H0)  # fb -> fa
+    W = W / W[2, 2]
+    cc = -1
+    for sc, bl in ((0.125, 5), (0.25, 5), (0.5, 3)):
+        As = cv2.GaussianBlur(cv2.resize(A, None, fx=sc, fy=sc, interpolation=cv2.INTER_AREA), (bl, bl), 0)
+        Bs = cv2.GaussianBlur(cv2.resize(B, None, fx=sc, fy=sc, interpolation=cv2.INTER_AREA), (bl, bl), 0)
+        Ssc = np.diag([sc, sc, 1.0]); Ws = Ssc @ W @ np.linalg.inv(Ssc)
+        try:
+            if modelo == "homog":
+                cc, Ws = cv2.findTransformECC(Bs, As, Ws.astype(np.float32), cv2.MOTION_HOMOGRAPHY, (cv2.TERM_CRITERIA_EPS | cv2.TERM_CRITERIA_COUNT, 150, 1e-6), None, 1)
+            else:
+                cc, W2 = cv2.findTransformECC(Bs, As, Ws[:2].astype(np.float32), cv2.MOTION_AFFINE, (cv2.TERM_CRITERIA_EPS | cv2.TERM_CRITERIA_COUNT, 150, 1e-6), None, 1)
+                Ws = np.vstack([W2, [0, 0, 1]])
+        except cv2.error:
+            return None, -1
+        W = np.linalg.inv(Ssc) @ Ws @ Ssc
+    return np.linalg.inv(W), cc
+f0 = int(math.ceil(t0 * 24 - 1e-6)); f1 = int(math.floor(t1 * 24 + 1e-6)); fa = int(round(tanc * 24))
+sol = {fa: (S_de(*json_cam(fa / 24.0)), 1.0)}
+for passo, lim in ((1, f1), (-1, f0)):
+    f = fa
+    while (f < lim if passo > 0 else f > lim):
+        g = f + passo
+        H0 = S_de(*json_cam(g / 24.0)) @ np.linalg.inv(S_de(*json_cam(f / 24.0)))   # movimento do json
+        H, cc = ecc(f, g, H0)
+        if H is None or cc < 0.5:
+            H, cc = H0, -1   # sem alinhamento: segue o json neste passo
+        elif "--sim" in a:
+            # projeta o passo numa similaridade (sem cisalhamento acumulado), preservando o centro da tela
+            H = H / H[2, 2]; A2 = H[:2, :2]; sc = math.sqrt(abs(np.linalg.det(A2))); rr = math.atan2(A2[1, 0] - A2[0, 1], A2[0, 0] + A2[1, 1])
+            c = H @ np.array([540, 540, 1.0]); c = c[:2] / c[2]
+            R2 = sc * np.array([[math.cos(rr), -math.sin(rr)], [math.sin(rr), math.cos(rr)]])
+            Hs = np.eye(3); Hs[:2, :2] = R2; Hs[:2, 2] = c - R2 @ np.array([540, 540]); H = Hs
+        sol[g] = (H @ sol[f][0], cc); f = g
+linhas = []
+for f in range(f0, f1 + 1):
+    cam, cp = decompor(sol[f][0]); jc = json_cam(f / 24.0)
+    linhas.append({"t": round(f / 24.0, 4), "zoom": cam[0], "mx": cam[1], "my": cam[2], "giro": cam[3], "cp": cp, "met": "ecc %.2f" % sol[f][1]})
+    print("%.3f ecc%5.2f z%6.3f M(%7.1f,%7.1f) g%6.2f pin %5.1f | json z%6.3f M(%7.1f,%7.1f) g%6.2f" % (f / 24.0, sol[f][1], cam[0], cam[1], cam[2], cam[3], max(abs(v) for v in cp), jc[0], jc[1], jc[2], jc[3]))
+json.dump({"cena": cid, "ancoras": [tanc], "margem": MG, "quadros": linhas}, open(out, "w"), indent=0)

package/lib/estudio/dados/projetos-ae/letra-nos-apps/camera/wg_finalizar_cam.py

@@ -0,0 +1,65 @@
+"""Câmera ajustada das cenas G, H, I, K (agente w-google, 17/10).
+
+A câmera medida (cena-<id>.json) confundia a inclinação 3D das interfaces com giro e errava zoom/mira nos
+chicotes. Aqui ela é refeita por homografia contra o quadro de referência (SIFT, direto ou em cadeia) e
+decomposta em: similaridade no centro da tela (controles do CAM: zoom, mira, giro) + resto projetivo
+(Corner Pin no comp da cena, guardado como deslocamento dos 4 cantos do quadro ampliado com margem).
+Entradas: JSON por quadro gerados por ajustar_h.py / ecc_cadeia.py (scratchpad do agente; o essencial está aqui).
+Saída: camera/cena-<id>-ajustada.json no formato do camera.jsx ({chaves: zoom, mx, my, giro}) + "pin" e "margem".
+Regras: Savitzky-Golay de 5 quadros; pin zerado no quadro da troca e misturado (smoothstep) até a primeira
+medida boa, para o encaixe encher a tela exatamente na troca.
+uso: python camera/wg_finalizar_cam.py <id> <entrada.json> [--pin-zero t_ini t_fim_rampa] [--json-ate t] [--mistura t0 t1]
+"""
+import sys, json, math, numpy as np
+from scipy.signal import savgol_filter
+a = sys.argv; cid = a[1]; ent = json.load(open(a[2]))
+P = "<SUA_CENTRAL>/07-videos/projetos/2026-10-17-subzmotion-recriacao/"
+q = ent["quadros"]; t = np.array([x["t"] for x in q])
+z = np.array([x["zoom"] for x in q]); mx = np.array([x["mx"] for x in q]); my = np.array([x["my"] for x in q]); g = np.array([x["giro"] for x in q])
+cp = np.array([x.get("cp", [0.0] * 8) for x in q])
+def ss(u): u = min(1, max(0, u)); return u * u * (3 - 2 * u)
+if "--pin-zero" in a:
+    i = a.index("--pin-zero"); ta, tb = float(a[i + 1]), float(a[i + 2])
+    jb = int(np.argmin(abs(t - tb))); alvo = cp[jb].copy()
+    for j in range(len(t)):
+        if t[j] <= ta + 1e-6: cp[j] = 0
+        elif t[j] < tb: cp[j] = alvo * ss((t[j] - ta) / (tb - ta))
+if "--mistura" in a:   # troca suave entre a câmera json (antes de t0) e a ajustada (depois de t1)
+    i = a.index("--mistura"); t0, t1 = float(a[i + 1]), float(a[i + 2])
+    d = json.load(open(P + "camera/cena-%s.json" % cid, encoding="utf-8"))["chaves"]
+    def jv(n, tt): return float(np.interp(tt, [x[0] for x in d[n]], [x[1] for x in d[n]]))
+    for j in range(len(t)):
+        if t[j] < t1:
+            w = ss((t[j] - t0) / (t1 - t0)) if t[j] > t0 else 0.0
+            z[j] = jv("zoom", t[j]) * (1 - w) + z[j] * w; mx[j] = jv("mx", t[j]) * (1 - w) + mx[j] * w
+            my[j] = jv("my", t[j]) * (1 - w) + my[j] * w; g[j] = jv("giro", t[j]) * (1 - w) + g[j] * w
+            cp[j] = cp[j] * w
+z, mx, my, g = [savgol_filter(v, 5, 2) for v in (z, mx, my, g)]
+cp = savgol_filter(cp, 5, 2, axis=0)
+if "--pin-zero" in a:
+    for j in range(len(t)):
+        if t[j] <= ta + 1e-6: cp[j] = 0
+src = json.load(open(P + "camera/cena-%s.json" % cid, encoding="utf-8"))
+out = {"fps": 24, "ini": src["ini"], "fim": src["fim"], "ref": src["ref"], "pegada": src["pegada"], "margem": ent.get("margem", 270),
+       "origem": "wg_finalizar_cam.py (homografia + Corner Pin)",
+       "chaves": {"zoom": [[round(float(t[j]), 4), round(float(z[j]), 4)] for j in range(len(t))],
+                  "mx": [[round(float(t[j]), 4), round(float(mx[j]), 3)] for j in range(len(t))],
+                  "my": [[round(float(t[j]), 4), round(float(my[j]), 3)] for j in range(len(t))],
+                  "giro": [[round(float(t[j]), 4), round(float(g[j]), 3)] for j in range(len(t))]},
+       "pin": [[round(float(t[j]), 4)] + [round(float(v), 2) for v in cp[j]] for j in range(len(t))]}
+json.dump(out, open(P + "camera/cena-%s-ajustada.json" % cid, "w"))
+print("ok", cid, len(t), "quadros; pin max %.1f" % abs(cp).max())
+# --- cantos do Corner Pin para a margem real do comp interno (alvo em coordenadas da camada interna)
+import cv2
+MR = float(a[a.index("--margem-real") + 1]) if "--margem-real" in a else out["margem"]
+MG = out["margem"]
+CANT = np.float32([[-MG, -MG], [1080 + MG, -MG], [-MG, 1080 + MG], [1080 + MG, 1080 + MG]])
+REAL = np.float32([[[-MR, -MR], [1080 + MR, -MR], [-MR, 1080 + MR], [1080 + MR, 1080 + MR]]])
+cantos = []
+for row in out["pin"]:
+    Pm = cv2.getPerspectiveTransform(CANT, (CANT + np.float32(row[1:]).reshape(4, 2)).astype(np.float32))
+    alvo = cv2.perspectiveTransform(REAL, Pm)[0] + MR
+    cantos.append([row[0]] + [round(float(v), 2) for v in alvo.ravel()])
+out["margem_real"] = MR; out["cantos"] = cantos
+json.dump(out, open(P + "camera/cena-%s-ajustada.json" % cid, "w"))
+print("cantos para margem real", MR)

package/lib/estudio/dados/projetos-ae/letra-nos-apps/camera/wg_mosaico.py

@@ -0,0 +1,61 @@
+# Mosaico do mundo com a câmera AJUSTADA (inclui rx, ry): python mosaico2.py <cam.json> <k> <saida.png> <x0 y0 x1 y1> [t0 t1] [--folha t,t,t saida_folha.png]
+import sys, json, math, cv2, numpy as np
+ORIG = "<SUA_CENTRAL>/05-pesquisa/referencias/2026-10-17-subzmotion/midia/05-DeMZpQ5gv-t.mp4"
+a = sys.argv; cam = json.load(open(a[1])); k = float(a[2]); out = a[3]; x0, y0, x1, y1 = [float(v) for v in a[4:8]]
+rest = [v for v in a[8:] if not v.startswith("--")]
+t0 = float(rest[0]) if len(rest) > 0 else -1; t1 = float(rest[1]) if len(rest) > 1 else 99
+F = 1500.0
+def projetar(p, W):
+    z, mx, my, g, rx, ry = p; s = 2 ** z; r = math.radians(g)
+    X = W[:, 0] - mx; Y = W[:, 1] - my
+    x = s * (math.cos(r) * X - math.sin(r) * Y); y = s * (math.sin(r) * X + math.cos(r) * Y); zz = np.zeros_like(x)
+    cy, sy = math.cos(math.radians(ry)), math.sin(math.radians(ry)); x, zz = x * cy + zz * sy, -x * sy + zz * cy
+    cx, sx = math.cos(math.radians(rx)), math.sin(math.radians(rx)); y, zz = y * cx - zz * sx, y * sx + zz * cx
+    return np.column_stack([540 + F * x / (F + zz), 540 + F * y / (F + zz)])
+MG = cam.get("margem", 270.0)
+CANT = np.float32([[-MG, -MG], [1080 + MG, -MG], [-MG, 1080 + MG], [1080 + MG, 1080 + MG]])
+def S_de(z, mx, my, g):
+    s = 2 ** z; r = math.radians(g); A = s * np.array([[math.cos(r), -math.sin(r)], [math.sin(r), math.cos(r)]])
+    T = np.eye(3); T[:2, :2] = A; T[:2, 2] = np.array([540, 540]) - A @ np.array([mx, my]); return T
+def Hq(q):
+    S = S_de(q["zoom"], q["mx"], q["my"], q["giro"])
+    if "cp" in q:
+        dst = (CANT + np.float32(q["cp"]).reshape(4, 2)).astype(np.float32); return cv2.getPerspectiveTransform(CANT, dst) @ S
+    p = [q[n] for n in ("zoom", "mx", "my", "giro", "rx", "ry")]
+    W = np.float32([[p[1] - 300, p[2] - 300], [p[1] + 300, p[2] - 300], [p[1] - 300, p[2] + 300], [p[1] + 300, p[2] + 300]])
+    return cv2.getPerspectiveTransform(W, projetar(p, W.astype(np.float64)).astype(np.float32))
+Wd = int((x1 - x0) * k); Hd = int((y1 - y0) * k)
+C = np.array([[k, 0, -x0 * k], [0, k, -y0 * k], [0, 0, 1.0]])   # mundo -> canvas
+canvas = np.zeros((Hd, Wd, 3), np.uint8); qual = np.full((Hd, Wd), -1e9, np.float32)
+cap = cv2.VideoCapture(ORIG); Q = {}
+qs = cam["quadros"]
+for i, q in enumerate(qs):
+    t = q["t"]
+    if t < t0 - 1e-6 or t > t1 + 1e-6: continue
+    f = int(round(t * 24)); cap.set(cv2.CAP_PROP_POS_FRAMES, f); ok, fr = cap.read()
+    if not ok: continue
+    H = Hq(q)                       # mundo -> tela
+    T = H @ np.linalg.inv(C)        # canvas -> tela
+    w = cv2.warpPerspective(fr, T, (Wd, Hd), flags=cv2.INTER_LINEAR | cv2.WARP_INVERSE_MAP)
+    m = cv2.warpPerspective(np.full(fr.shape[:2], 255, np.uint8), T, (Wd, Hd), flags=cv2.INTER_NEAREST | cv2.WARP_INVERSE_MAP) > 0
+    m = cv2.erode(m.astype(np.uint8), np.ones((3, 3), np.uint8)) > 0
+    nx = qs[min(i + 1, len(qs) - 1)]
+    spd = math.hypot(nx["mx"] - q["mx"], nx["my"] - q["my"]) * 2 ** q["zoom"] + abs(nx["zoom"] - q["zoom"]) * 370 + abs(nx.get("rx", 0) - q.get("rx", 0)) * 9
+    qq = 2 ** q["zoom"] / (1 + spd / 6) if q["met"] not in ("buraco", "json") else -1e6
+    u = m & (qq > qual); canvas[u] = w[u]; qual[u] = qq
+cv2.imwrite(out, canvas)
+g = canvas.copy()
+for gx in range(int(math.ceil(x0 / 100)) * 100, int(x1), 100):
+    X = int((gx - x0) * k); cv2.line(g, (X, 0), (X, Hd), (0, 0, 255) if gx % 500 == 0 else (0, 128, 255), 1); cv2.putText(g, str(gx), (X + 2, 14), 0, 0.4, (0, 0, 255), 1)
+for gy in range(int(math.ceil(y0 / 100)) * 100, int(y1), 100):
+    Y = int((gy - y0) * k); cv2.line(g, (0, Y), (Wd, Y), (0, 0, 255) if gy % 500 == 0 else (0, 128, 255), 1); cv2.putText(g, str(gy), (2, Y - 2), 0, 0.4, (0, 0, 255), 1)
+cv2.imwrite(out.replace(".png", "-grade.png"), g)
+if "--folha" in a:
+    i = a.index("--folha"); tt = [float(v) for v in a[i + 1].split(",")]; fo = a[i + 2]; tiles = []
+    for t in tt:
+        q = min(qs, key=lambda x: abs(x["t"] - t)); f = int(round(q["t"] * 24)); cap.set(cv2.CAP_PROP_POS_FRAMES, f); ok, fr = cap.read()
+        pr = cv2.warpPerspective(canvas, Hq(q) @ np.linalg.inv(C), (1080, 1080))
+        row = np.hstack([cv2.resize(fr, (360, 360)), cv2.resize(pr, (360, 360)), cv2.resize(cv2.absdiff(fr, pr), (360, 360))])
+        cv2.putText(row, "%.3f %s" % (q["t"], q["met"]), (4, 16), 0, 0.5, (0, 255, 255), 1); tiles.append(row)
+    cv2.imwrite(fo, np.vstack(tiles))
+print("ok", out, Wd, Hd)

package/lib/estudio/dados/projetos-ae/letra-nos-apps/guia-do-metodo/tutorial-lyric-edit-interfaces/01-gramatica-e-roteiro.md

@@ -0,0 +1,55 @@
+# Lyric edit em interfaces · 01 · Gramática e roteiro
+
+> Data: 2026-10-17 · Tipo: tutorial · Status: vigente
+
+**Resumo:** o que faz o estilo funcionar (medido nos 3 edits do @subzmotion), como escolher a música, como transformar cada frase numa interface e como montar o roteiro de cenas com os campos de letra. Volta para o [índice](../tutorial-lyric-edit-interfaces.md).
+
+## 1. A gramática (o que não pode faltar)
+
+1. **A palavra vira lugar.** Cada frase é digitada no campo que faz sentido para ela. Interface reconhecível em todas as cenas.
+2. **Digitação no tempo da voz.** Letra a letra com cursor "|" (1–3 quadros por letra), começando até 0,35 s antes da palavra cantada. Em títulos e balões, a palavra também pode cair desfocada no lugar em 3–6 quadros. Interface de letra (Spotify) = karaokê, palavra cantada acesa.
+3. **Cena dentro de cena.** A cena anterior continua tocando dentro de um elemento pequeno da seguinte (avatar, ícone de app, foto de jornal, miniatura de janela, marcador de mapa). A máscara morfa (retângulo → círculo ou quadrado arredondado) enquanto a câmera recua. Nada de corte seco.
+4. **Câmera que nunca para**, em cadeia de nulls (parte 02). Só o último meio segundo fica parado.
+5. **3D sem câmera:** jornal, celular, livro como camadas 3D deitadas, vistas pela câmera padrão da comp.
+6. **Borrão de movimento** ligado, obturador ~90° (rastro ≈ ¼ do deslocamento do quadro).
+7. **Formato:** 1080×1080 a 24 qps, música da biblioteca do Instagram (ou o mix), sem efeito sonoro além da música no original. No nosso: card do Spotify no fim e abertura do celular (parte 05).
+
+Por que viraliza (inferência da pesquisa): música conhecida + interface que todo mundo usa = reconhecimento imediato a cada frase; take único com câmera viva; a timeline postada no dia seguinte vira prova de trabalho manual.
+
+## 2. Música e trecho
+
+- Trecho de 30–40 s, de preferência o refrão ou a parte mais conhecida; 5–8 versos curtos funcionam melhor que frases longas.
+- Áudio: o arquivo da música (ou o do Reel de referência, só como referência interna) em `audio/musica.wav`.
+- **Letra:** o autor copia a letra inteira (Google, Spotify) e cola em `ae/LETRA-COMPLETA.txt`. Pode ser a música inteira: o script acha o trecho. O Claude não escreve nem copia letra de música; explique isso em uma linha se ele pedir.
+- **Idioma:** a interface acompanha a música (música em inglês → interface em inglês). Nada de traduzir a letra.
+
+## 3. Frase → interface (mapa que já funcionou)
+
+| A frase fala de… | Interface | Exemplo do On My Way |
+|---|---|---|
+| tempo, compromisso, "quando" | Google Agenda: título de evento, cartão de detalhes | 0–2,6 s |
+| procurar, querer, perguntar | busca do Google, Docs, painel de conhecimento | 2,9–4,4 s; 16,7–19 s; 22,4–24,9 s |
+| mundo, lugar grande | globo com texto curvo | 4,4–5,0 s |
+| trocar de assunto | alt-tab do Windows / app switcher | 5,0–6,0 s |
+| ouvir, cantar | Spotify em tela cheia de letra (karaokê) | 6,0–8,3 s |
+| falar de alguém, status | notas do Instagram (balão em cima do avatar) | 8,3–11 s |
+| afirmação forte, manchete | jornal 3D sobre mesa | 11–16,7 s; 24,9–28,2 s |
+| caminho, chegar, "onde" | mapa de jogo (etiqueta-seta) ou Google Maps (pino, busca, avatar andando) | 19–22,3 s; 28,2–33,9 s |
+| mensagem para alguém | WhatsApp, DM, iMessage | Rockabye e Love Story |
+
+Outras do autor: Apple Maps, feed do Instagram, polaroides na mesa, livro que fecha, post-it na parede, widgets do iOS ("Hard Times").
+
+## 4. Roteiro de cenas (como montar)
+
+1. `python -P audio/tempos_da_voz.py audio/musica.wav`: tempo de cada palavra cantada, por verso, sem guardar a letra (`audio/musica-tempos.txt`). É a régua do roteiro. (`ae/letra_automatica.py --teste` confere o encaixe dos campos sem texto nenhum.)
+2. Divida em cenas-mundo de 1,5–6 s. Cada cena tem: tempo de início/fim, interface, quais palavras são digitadas em quais campos, e **o buraco** (elemento onde a cena anterior entra) ou a janela (onde a próxima abre, se for avanço).
+3. Escreva o `ROTEIRO-CENAS.md` do projeto (molde: o do projeto-modelo) e a lista de campos em `ae/letra.json`: um slot por campo, com `onde`, `palavras` (quantas palavras o campo mostra) e `canta_em` (os tempos). O `letra_automatica.py` usa janelas de tempo por campo (constante `JANELAS`) e regras de caixa alta / inicial maiúscula (`CAIXA_ALTA`, `INICIAL_MAIUSCULA`): ajuste para a música nova.
+4. Depois que o autor colar a letra: `python -P ae/letra_automatica.py`. Ele imprime "campo · palavras (colado / original)"; diferença de ±1 em algum campo quase sempre é uma palavra que o Whisper ouviu diferente e caiu na janela vizinha: mova a divisa entre as duas janelas (foi o caso de I2/J1 no On My Way).
+5. Pontuação e grafia vêm do texto colado (apóstrofo reto, grafia americana). Se ele quiser idêntico ao original, ele corrige no próprio json.
+
+## 5. Personagens, imagens e fontes
+
+- **Pessoas:** personagens nossos pelo GPT Image 2 (`python -P 08-integracoes/codex-imagem.py "prompt em inglês" saida.png`, ~50 s cada, até 3 em paralelo). Gere os que aparecem em várias cenas uma vez só em `assets/comum/` (avatar, papel de parede) e reutilize. Nada de rosto real conhecido nem marca de jogo: vira "Studio Quadro" e afins.
+- **Fotos e texturas:** mesa de madeira vista de cima, mapa de satélite estilo jogo, céu, foto antiga P&B, renders abstratos para painéis: tudo gerado.
+- **Ícones de apps:** oficiais do simpleicons/Wikimedia.
+- **Fontes que usamos:** Google Sans Flex (Google), Figtree (Spotify), Roboto (Instagram/Maps), Segoe UI (Windows), Noto Serif Display ExtraCondensed (manchetes), Poppins SemiBold (texto curvo do globo). Fonte nova vai em `C:\Program Files\Common Files\Adobe\Fonts` e só aparece depois de reiniciar a cópia do AE.