primocode 10.13.0 → 10.14.0

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

@@ -0,0 +1,61 @@
+"""Ajusta a câmera medida de cada cena a uma SOMA DE MOVIMENTOS com ease do AE (o rig do autor:
+um null por movimento, 2 keyframes com velocidade zero nas pontas e influências de saída/entrada).
+Cada movimento k: início a, duração D, influência de saída u (1º keyframe), de entrada w (2º keyframe),
+e deltas em zoom (log2), mira x, mira y, giro. Canal(t) = valor_inicial + soma_k delta_k * ease_k(t).
+Saída: camera/movimentos.json (por cena) + estatística das durações e influências."""
+import json, sys, numpy as np
+from scipy.optimize import least_squares
+from scipy.signal import find_peaks, savgol_filter
+sys.stdout.reconfigure(encoding="utf-8")
+FPS = 24.0
+def ease(tau, u, w):
+    """Progresso 0..1 da curva temporal do AE com velocidade 0 nas duas pontas (bezier 0,u | 1-w,1)."""
+    tau = np.clip(tau, 0, 1); s = tau.copy()
+    for _ in range(30):  # Newton em x(s) = tau
+        x = 3 * (1 - s) ** 2 * s * u + 3 * (1 - s) * s ** 2 * (1 - w) + s ** 3
+        dx = 3 * (1 - s) ** 2 * u + 6 * (1 - s) * s * (1 - w - u) + 3 * s ** 2 * w
+        s = np.clip(s - (x - tau) / np.maximum(dx, 1e-6), 0, 1)
+    return 3 * (1 - s) * s ** 2 + s ** 3
+def modelo(p, t, K, base):
+    out = np.tile(base[:, None], (1, len(t))).astype(float)
+    for k in range(K):
+        a, D, u, w, dz, dx, dy, dg = p[8 * k: 8 * k + 8]
+        e = ease((t - a) / max(D, 1 / FPS), u, w)
+        out += np.array([dz, dx, dy, dg])[:, None] * e[None, :]
+    return out
+d = json.load(open("camera/camera-ancorada.json")); res = {}; todos = []
+for cena, v in d.items():
+    q = v["quadros"]; t = np.array([x["t"] for x in q])
+    Y = np.array([np.log2([x["s"] for x in q]), [x["wx"] for x in q], [x["wy"] for x in q], [x["rot"] for x in q]])
+    if cena in ("A-agenda", "B-docs", "C-alttab", "D-spotify", "E-notas"): Y[3] = 0
+    esc = np.array([1.0, 1 / 200, 1 / 200, 1 / 10])        # pesos: 1 oitava de zoom ~ 200 px de mira ~ 10° de giro
+    vel = np.sqrt((np.gradient(Y, axis=1) * esc[:, None] * FPS) ** 2).sum(0)
+    vel = savgol_filter(vel, 5, 2) if len(vel) > 7 else vel
+    pk, _ = find_peaks(vel, distance=6, prominence=max(0.15, 0.08 * vel.max()))
+    K = max(1, len(pk)); p0, lo, hi = [], [], []
+    for i in pk if len(pk) else [int(np.argmax(vel))]:
+        a0 = t[i] - 0.2; D0 = 0.8
+        j0, j1 = max(0, int(i - 5)), min(len(t) - 1, int(i + 14))
+        dl = Y[:, j1] - Y[:, j0]
+        p0 += [a0, D0, 0.25, 0.75, *dl]; lo += [t[0] - 1.5, 4 / FPS, 0.01, 0.01, -12, -5000, -5000, -90]; hi += [t[-1] + 0.5, 3.0, 1.0, 1.0, 12, 5000, 5000, 90]
+    base = Y[:, 0].copy()
+    def resid(p):
+        return ((modelo(p, t, K, base) - Y) * esc[:, None]).ravel()
+    r = least_squares(resid, np.clip(p0, lo, hi), bounds=(lo, hi), max_nfev=4000)
+    erro = np.sqrt(np.mean(resid(r.x) ** 2)); amp = np.sqrt(np.mean(((Y - Y.mean(1, keepdims=True)) * esc[:, None]) ** 2))
+    movs = []
+    for k in range(K):
+        a, D, u, w, dz, dx, dy, dg = r.x[8 * k: 8 * k + 8]
+        movs.append({"ini": round(a, 3), "dur": round(D, 3), "infl_saida": round(u * 100, 1), "infl_entrada": round(w * 100, 1),
+                     "zoom_log2": round(dz, 3), "mira_x": round(dx, 1), "mira_y": round(dy, 1), "giro": round(dg, 2)})
+        if abs(dz) > 0.1 or np.hypot(dx, dy) > 30: todos.append((D, u, w))
+    movs.sort(key=lambda m: m["ini"])
+    res[cena] = {"base": {"zoom_log2": round(base[0], 3), "mira_x": round(base[1], 1), "mira_y": round(base[2], 1), "giro": round(base[3], 2)},
+                 "movimentos": movs, "erro_rel": round(erro / max(amp, 1e-6), 3)}
+    print(f"{cena:10s} {K:2d} movimentos | erro relativo {erro / max(amp, 1e-6):.3f}")
+json.dump(res, open("camera/movimentos.json", "w", encoding="utf-8"), indent=1, ensure_ascii=False)
+A = np.array(todos)
+if len(A):
+    print(f"\n{len(A)} movimentos relevantes | duração mediana {np.median(A[:,0]):.2f} s ({np.median(A[:,0])*FPS:.0f} quadros), quartis {np.percentile(A[:,0],25):.2f}–{np.percentile(A[:,0],75):.2f} s")
+    print(f"influência de saída (1º key) mediana {np.median(A[:,1])*100:.0f}% (quartis {np.percentile(A[:,1],25)*100:.0f}–{np.percentile(A[:,1],75)*100:.0f}%)")
+    print(f"influência de entrada (2º key) mediana {np.median(A[:,2])*100:.0f}% (quartis {np.percentile(A[:,2],25)*100:.0f}–{np.percentile(A[:,2],75)*100:.0f}%)")

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

@@ -0,0 +1,74 @@
+"""Corrige a deriva da câmera integrada: casa cada quadro direto com o quadro de referência da cena (SIFT)
+e usa essas medidas absolutas como âncoras; entre âncoras, a correção é interpolada no tempo.
+Entrada: vídeo original, camera-medida.json. Saída: camera-ancorada.json (mesmo formato) + relatório."""
+import json, sys, cv2, numpy as np
+sys.stdout.reconfigure(encoding="utf-8")
+VID, MED, OUT = sys.argv[1], sys.argv[2], sys.argv[3]
+M = json.load(open(MED)); FPS = 24.0
+cap = cv2.VideoCapture(VID); quadros = []
+while True:
+    ok, q = cap.read()
+    if not ok: break
+    quadros.append(cv2.cvtColor(q, cv2.COLOR_BGR2GRAY))
+sift = cv2.SIFT_create(nfeatures=4000)
+cache = {}
+def kp(f):
+    if f not in cache: cache[f] = sift.detectAndCompute(quadros[f], None)
+    return cache[f]
+bf = cv2.BFMatcher()
+def casar(fr, f):
+    """Similaridade que leva a tela do quadro de referência fr para a tela do quadro f (3x3) ou None."""
+    k1, d1 = kp(fr); k2, d2 = kp(f)
+    if d1 is None or d2 is None or len(k1) < 10 or len(k2) < 10: 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.72 * n.distance]
+    if len(bons) < 15: 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=4.0)
+    if A is None: return None, 0
+    n = int(inl.sum())
+    if n < 20 or n / len(bons) < 0.35: return None, n
+    T = np.eye(3); T[:2] = A
+    return T, n
+def S_de(q):
+    """Matriz mundo->tela a partir do estado (s, rot, wx, wy)."""
+    s, r = q["s"], np.radians(q["rot"]); R = s * np.array([[np.cos(r), -np.sin(r)], [np.sin(r), np.cos(r)]])
+    T = np.eye(3); T[:2, :2] = R; T[:2, 2] = np.array([540, 540]) - R @ np.array([q["wx"], q["wy"]]); return T
+def estado_de(S):
+    A = S[:2, :2]; s = float(np.sqrt(abs(np.linalg.det(A)))); r = float(np.degrees(np.arctan2(A[1, 0], A[0, 0])))
+    w = np.linalg.inv(S) @ np.array([540, 540, 1.0]); return s, r, float(w[0]), float(w[1])
+saida = {}
+for k, v in M.items():
+    fr = int(round(v["ref"] * FPS)); q = v["quadros"]
+    anc = {}
+    for i, x in enumerate(q):
+        f = x["f"]
+        if f >= len(quadros): continue
+        if f == fr: anc[i] = np.eye(3); continue
+        if i % 2: continue
+        T, n = casar(fr, f)
+        if T is None: continue
+        Sabs = T  # mundo (= tela em fr) -> tela em f
+        if abs(np.linalg.det(Sabs[:2, :2])) < 1e-6: continue
+        sa, ra, _, _ = estado_de(Sabs); si = q[i]["s"]
+        if not (0.2 < sa / si < 5): continue  # casamento absurdo
+        anc[i] = Sabs
+    # correção C = Sabs * Sint^-1 nas âncoras, parametrizada (log s, rot, tx, ty) e interpolada
+    idx = sorted(anc)
+    par = []
+    for i in idx:
+        C = anc[i] @ np.linalg.inv(S_de(q[i])); A = C[:2, :2]
+        par.append([np.log(np.sqrt(abs(np.linalg.det(A)))), np.arctan2(A[1, 0], A[0, 0]), C[0, 2], C[1, 2]])
+    par = np.array(par) if par else np.zeros((0, 4))
+    novos = []
+    for i, x in enumerate(q):
+        if len(idx) == 0: c = [0, 0, 0, 0]
+        else: c = [np.interp(i, idx, par[:, j]) for j in range(4)]
+        Cs = np.exp(c[0]); Cr = c[1]; C = np.eye(3); C[:2, :2] = Cs * np.array([[np.cos(Cr), -np.sin(Cr)], [np.sin(Cr), np.cos(Cr)]]); C[:2, 2] = c[2:]
+        s, r, wx, wy = estado_de(C @ S_de(x))
+        novos.append({"f": x["f"], "t": x["t"], "s": round(s, 5), "rot": round(r, 3), "wx": round(wx, 2), "wy": round(wy, 2)})
+    cobertura = len(idx) / max(1, len(q) / 2)
+    saida[k] = dict(v, quadros=novos, ancoras=[q[i]["t"] for i in idx])
+    d0 = abs(np.log(novos[0]["s"] / q[0]["s"])); dw = np.hypot(novos[0]["wx"] - q[0]["wx"], novos[0]["wy"] - q[0]["wy"])
+    print(f"{k:10s} âncoras {len(idx):3d} ({cobertura*100:4.0f}% dos quadros pares) | início: zoom {q[0]['s']:.2f}->{novos[0]['s']:.2f}, mira desloca {dw:.0f} px | faixa das âncoras {min(saida[k]['ancoras']) if idx else '-'}–{max(saida[k]['ancoras']) if idx else '-'}")
+json.dump(saida, open(OUT, "w"), indent=0)

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

@@ -0,0 +1,47 @@
+"""Transforma a câmera medida (camera-medida.json) em keyframes por cena + geometria dos encaixes.
+
+Limpeza (decidida olhando os quadros, ver README):
+- giro zerado nas cenas planas (A, B, C, D, E): o rastreio pegou giro falso em trocas de conteúdo;
+- trechos em que um ELEMENTO se mexe sozinho (não a câmera) ficam com a câmera segurada:
+  B 4,46–4,83 s (globo entrando) e C 5,80–6,04 s (janela do Spotify abrindo);
+- K: o giro do comecinho é do jornal girado dentro do pino; giro começa igual ao de 28,40 s.
+Suavização: Savitzky-Golay de 5 quadros (tira tremida do rastreio sem matar os picos).
+Saída: camera/cena-<id>.json  {fps, ini, fim, chaves: {zoom: [[t, log2 s]], mx, my, giro}} (tempo = tempo do vídeo)
+       camera/encaixes.json   onde a cena anterior/seguinte precisa estar no mundo desta cena no instante da troca.
+"""
+import json, math, numpy as np
+from scipy.signal import savgol_filter
+M = json.load(open("camera/camera-ancorada.json"))
+PLANAS = {"A-agenda", "B-docs", "C-alttab", "D-spotify", "E-notas"}
+SEGURA = {"B-docs": [(4.46, 4.83)], "C-alttab": [(5.80, 6.04)]}
+cenas = {}
+for k, v in M.items():
+    q = v["quadros"]; t = np.array([x["t"] for x in q])
+    z = np.log2([x["s"] for x in q]); mx = np.array([x["wx"] for x in q]); my = np.array([x["wy"] for x in q]); g = np.array([x["rot"] for x in q])
+    if k in PLANAS: g[:] = 0
+    if k == "K-maps":
+        i0 = int(np.argmin(abs(t - 28.40))); g[:i0] = g[i0]
+    for a, b in SEGURA.get(k, []):
+        m = (t >= a) & (t <= b); i = int(np.argmax(m)) - 1
+        for arr in (z, mx, my, g): arr[m] = arr[i]
+    if len(t) >= 7:
+        z, mx, my, g = [savgol_filter(a, 5, 2) for a in (z, mx, my, g)]
+    ch = {"zoom": z, "mx": mx, "my": my, "giro": g}
+    cenas[k] = {"fps": 24, "ini": v["ini"], "fim": v["fim"], "ref": v["ref"], "pegada": v["pegada"],
+                "chaves": {n: [[round(float(tt), 4), round(float(a[i]), 4)] for i, tt in enumerate(t)] for n, a in ch.items()}}
+    json.dump(cenas[k], open(f"camera/cena-{k}.json", "w"))
+ids = list(cenas)
+enc = []
+def estado(k, tt):
+    ch = cenas[k]["chaves"]; i = min(range(len(ch["zoom"])), key=lambda j: abs(ch["zoom"][j][0] - tt))
+    return 2 ** ch["zoom"][i][1], ch["mx"][i][1], ch["my"][i][1], ch["giro"][i][1]
+for a, b in zip(ids, ids[1:]):
+    ts = cenas[b]["ini"]
+    if b == "D-spotify":   # empurra: a cena seguinte (Spotify) mora numa janela do alt-tab
+        s, x, y, r = estado(a, ts); onde, quem = a, b
+    else:                   # recua: a cena anterior mora num elemento da seguinte
+        s, x, y, r = estado(b, ts); onde, quem = b, a
+    enc.append({"troca_s": ts, "mundo_de": onde, "cena_encaixada": quem, "centro": [round(x, 2), round(y, 2)],
+                "lado": round(1080 / s, 3), "escala_pct": round(100 / s, 4), "giro": round(-r, 3)})
+    print(f"{ts:6.2f}s  {quem:10s} dentro de {onde:10s}: centro ({x:7.1f},{y:7.1f})  lado {1080/s:7.1f} px  ({100/s:6.2f}%)  giro {-r:5.2f}")
+json.dump(enc, open("camera/encaixes.json", "w"), indent=1)

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

@@ -0,0 +1,172 @@
+"""Câmera 3D das cenas do jornal (F-jornal1, J-jornal2) a partir da homografia medida no original.
+
+Achado (17/10): com a página "plana" bem definida, o original bate com a câmera padrão do AE para comp 1080
+(zoom 1500 px, centro óptico no centro) e o jornal girando em 3D: erro médio < 1 px. É o rig do autor: camadas
+3D, sem camada de câmera.
+
+Passos:
+ 1) homografia-<X>.json leva a tela do quadro-base para a tela de cada quadro (homografia_jornal.py);
+ 2) o plano verdadeiro = Hr · (tela do quadro-base - 540), com Hr = retificação de 4 parâmetros (a página pode
+    não estar 100% de frente no quadro-base); Hr é escolhida para minimizar o erro de todos os quadros;
+ 3) por quadro: pose (R, t) do plano para a câmera fixa f = 1500 (solvePnP + mínimos quadrados);
+ 4) no começo da cena a pose é misturada com a pose "de frente" (para o encaixe encher a tela sem quina);
+ 5) saída para o AE: null 3D "PLANO" (ponto de ancoragem 0) com Posição = t + [540, 540, -1500] e
+    Rotação X/Y/Z tais que Rx·Ry·Rz = R (ordem do AE medida no próprio AE).
+Saída: camera/camera3d-<X>.json  {f, quadros: [{f, t, pos, rot:[x,y,z], erro_px}], Hr, encaixe}
+Uso: python -I camera3d_jornal.py F|J
+"""
+import json, sys, numpy as np, cv2
+from scipy.optimize import least_squares, minimize
+sys.stdout.reconfigure(encoding="utf-8")
+CENA = sys.argv[1]
+FOC, C = 1500.0, 540.0
+K = np.array([[FOC, 0, C], [0, FOC, C], [0, 0, 1.0]])
+d = json.load(open(f"homografia-{CENA}.json"))
+H = {int(k): np.array(v) for k, v in d["H"].items()}
+fs = sorted(H)
+# troca no 1º quadro inteiro da cena (10,80 s e 24,62 s caem entre quadros: 1º quadro visível = 260 e 591)
+TROCA = {"F": 260 / 24, "J": 591 / 24}[CENA]
+MISTURA = {"F": (260 / 24, 11.00), "J": (591 / 24, 24.80)}[CENA]
+gx = np.linspace(60, 1020, 7)
+GRADE = np.array([[x, y] for y in gx for x in gx], float)
+
+
+def Hr_de(g):
+    a, b, p, q = g
+    return np.array([[1 + a, b, 0], [0, 1, 0], [p / 1000, q / 1000, 1.0]])
+
+
+def plano_de_tela(f, g, uv):
+    Hi = np.linalg.inv(H[f]); P = (Hi @ np.c_[uv, np.ones(len(uv))].T).T; x = P[:, :2] / P[:, 2:3] - C
+    Q = (Hr_de(g) @ np.c_[x, np.ones(len(x))].T).T
+    return Q[:, :2] / Q[:, 2:3]
+
+
+def proj(p, X):
+    R, _ = cv2.Rodrigues(p[:3]); Xc = (R @ np.c_[X, np.zeros(len(X))].T).T + p[3:6]
+    return np.c_[FOC * Xc[:, 0] / Xc[:, 2] + C, FOC * Xc[:, 1] / Xc[:, 2] + C]
+
+
+def pose(f, g, p0=None):
+    X = plano_de_tela(f, g, GRADE); u = GRADE
+    ok, rv, tv = cv2.solvePnP(np.c_[X, np.zeros(len(X))], u, K, None, flags=cv2.SOLVEPNP_IPPE)
+    inits = [np.r_[rv.ravel(), tv.ravel()]]
+    if p0 is not None: inits.append(p0)
+    best = None
+    for q0 in inits:
+        s = least_squares(lambda p: (proj(p, X) - u).ravel(), q0, method="lm", max_nfev=200)
+        e = float(np.sqrt(((proj(s.x, X) - u) ** 2).sum(1)).mean())
+        if best is None or e < best[1]: best = (s.x, e)
+    return best
+
+
+cache = {}
+def custo(g):
+    tot = []
+    for f in fs[::2]:
+        p, e = pose(f, g, cache.get(f)); cache[f] = p; tot.append(e)
+    return float(np.mean(np.array(tot) ** 2))
+
+
+print("sem retificação: rms", custo(np.zeros(4)) ** .5)
+r = minimize(custo, np.zeros(4), method="Nelder-Mead",
+             options={"xatol": 1e-6, "fatol": 1e-4, "maxiter": 300,
+                      "initial_simplex": np.array([[0, 0, 0, 0], [.02, 0, 0, 0], [0, .02, 0, 0], [0, 0, .05, 0], [0, 0, 0, .05]])})
+g = r.x
+print("retificação (Nelder-Mead)", np.round(g, 6), "rms", r.fun ** .5)
+# ajuste conjunto (retificação + todas as poses) por mínimos quadrados esparsos
+from scipy.sparse import lil_matrix
+N = len(fs); NP = 4 + 6 * N
+x0 = np.r_[g, np.concatenate([pose(f, g, cache.get(f))[0] for f in fs])]
+def res_all(x):
+    gg = x[:4]; out = []
+    for i, f in enumerate(fs):
+        X = plano_de_tela(f, gg, GRADE); out.append((proj(x[4 + 6 * i: 10 + 6 * i], X) - GRADE).ravel())
+    return np.concatenate(out)
+M = len(GRADE) * 2
+J = lil_matrix((M * N, NP), dtype=int)
+for i in range(N):
+    J[i * M:(i + 1) * M, :4] = 1; J[i * M:(i + 1) * M, 4 + 6 * i: 10 + 6 * i] = 1
+sol = least_squares(res_all, x0, jac_sparsity=J, x_scale="jac", max_nfev=200, verbose=0)
+g = sol.x[:4]
+for i, f in enumerate(fs): cache[f] = sol.x[4 + 6 * i: 10 + 6 * i]
+rr = sol.fun.reshape(N, -1, 2); print("retificação (conjunto)", np.round(g, 6), "rms", float(np.sqrt((rr ** 2).sum(2)).mean()))
+poses = {}
+for f in fs:
+    poses[f] = pose(f, g, cache.get(f))
+
+
+def frontal(p):
+    """Mesma pose, sem inclinação: a normal do plano alinhada ao eixo da câmera (mantém o giro no plano e t)."""
+    R, _ = cv2.Rodrigues(p[:3])
+    n = R[:, 2]  # normal do plano em coordenadas da câmera
+    # rotação mínima que leva n para (0,0,1)
+    z = np.array([0, 0, 1.0]); v = np.cross(n, z); s = np.linalg.norm(v); c = float(n @ z)
+    if s < 1e-9: return p.copy()
+    vx = np.array([[0, -v[2], v[1]], [v[2], 0, -v[0]], [-v[1], v[0], 0]])
+    Rm = np.eye(3) + vx + vx @ vx * ((1 - c) / s ** 2)
+    R2 = Rm @ R
+    # mantém o ponto do plano que está no centro da tela no mesmo lugar e à mesma distância
+    t = p[3:6]
+    Xc0 = np.array([0, 0, 1.0]) * 1.0
+    # ponto do plano no eixo óptico: R X + t = lambda * z
+    A = np.c_[R[:, 0], R[:, 1], -z]; sol = np.linalg.solve(A, -t); X0 = np.array([sol[0], sol[1], 0]); lam = sol[2]
+    t2 = lam * z - R2 @ X0
+    return np.r_[cv2.Rodrigues(R2)[0].ravel(), t2]
+
+
+def slerp_pose(pa, pb, w):
+    Ra, _ = cv2.Rodrigues(pa[:3]); Rb, _ = cv2.Rodrigues(pb[:3])
+    dr, _ = cv2.Rodrigues(Rb @ Ra.T); Rw = cv2.Rodrigues(dr * w)[0] @ Ra
+    return np.r_[cv2.Rodrigues(Rw)[0].ravel(), (1 - w) * pa[3:6] + w * pb[3:6]]
+
+
+a0, a1 = MISTURA
+final = {}
+for f in fs:
+    p, e = poses[f]
+    t = f / 24
+    if t < a1:
+        w = 0.0 if t <= a0 else (t - a0) / (a1 - a0)
+        w = w * w * (3 - 2 * w)
+        p = slerp_pose(frontal(p), p, w)
+        X = plano_de_tela(f, g, GRADE); e = float(np.sqrt(((proj(p, X) - GRADE) ** 2).sum(1)).mean())
+    final[f] = (p, e)
+
+
+def euler_ae(R):
+    """R = Rx(a)·Ry(b)·Rz(c) (ordem do AE) -> [a, b, c] em graus."""
+    b = np.arcsin(np.clip(R[0, 2], -1, 1)); c = np.arctan2(-R[0, 1], R[0, 0]); a = np.arctan2(-R[1, 2], R[2, 2])
+    return np.degrees([a, b, c])
+
+
+out = []
+prev = None
+for f in fs:
+    p, e = final[f]
+    R, _ = cv2.Rodrigues(p[:3]); t = p[3:6]
+    rot = euler_ae(R)
+    if prev is not None:  # sem saltos de 360°
+        rot = prev + ((rot - prev + 180) % 360 - 180)
+    prev = rot
+    out.append({"f": f, "t": round(f / 24, 5), "pos": (t + np.array([C, C, -FOC])).tolist(), "rot": rot.tolist(),
+                "R": R.tolist(), "tc": t.tolist(), "erro_px": round(e, 2)})
+    print(f, f"{f/24:7.3f}", "pos", np.round(t + [C, C, -FOC], 1), "rot", np.round(rot, 2), f"erro {e:.2f}")
+
+# encaixe: quadrado na tela no instante da troca -> quadrilátero no plano (com a pose interpolada na troca)
+f0 = max(f for f in fs if f / 24 <= TROCA); f1 = f0 + 1
+w = (TROCA - f0 / 24) * 24
+pt = slerp_pose(final[f0][0], final[f1][0], w)
+R, _ = cv2.Rodrigues(pt[:3]); tt = pt[3:6]
+cantos = []
+for u, v in ((0, 0), (1080, 0), (1080, 1080), (0, 1080)):
+    ray = np.array([(u - C) / FOC, (v - C) / FOC, 1.0])
+    # R X + t = s ray, X=(x,y,0)
+    A = np.c_[R[:, 0], R[:, 1], -ray]; sol = np.linalg.solve(A, -tt); cantos.append([sol[0], sol[1]])
+cantos = np.array(cantos)
+cen = cantos.mean(0); lado = float(np.linalg.norm(cantos[1] - cantos[0]))
+giro = float(np.degrees(np.arctan2(cantos[1][1] - cantos[0][1], cantos[1][0] - cantos[0][0])))
+print("encaixe no plano: cantos", np.round(cantos, 2).tolist(), "centro", np.round(cen, 2), "lado", round(lado, 3), "giro", round(giro, 3))
+json.dump({"foco": FOC, "Hr": Hr_de(g).tolist(), "g": g.tolist(), "troca": TROCA, "mistura": MISTURA,
+           "encaixe": {"cantos": cantos.tolist(), "centro": cen.tolist(), "lado": lado, "giro": giro},
+           "quadros": out}, open(f"camera3d-{CENA}.json", "w"), indent=0)

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

@@ -0,0 +1,32 @@
+"""Compara a câmera do original com a da recriação (zoom, dx, dy, giro por quadro), cena a cena.
+Uso: python -P comparar.py original.csv recriacao.csv cenas.json saida_prefixo
+(os CSVs saem do medir_quadro_a_quadro.py rodado em cada vídeo)."""
+import sys, csv, json, numpy as np
+import matplotlib; matplotlib.use("Agg"); import matplotlib.pyplot as plt
+sys.stdout.reconfigure(encoding="utf-8")
+def ler(p):
+    R = list(csv.DictReader(open(p)))
+    f = lambda k: np.array([float(r[k]) if r[k] not in ("nan", "") else np.nan for r in R])
+    return f("t"), (f("descala") - 1) * 100, f("dx_px1080"), f("dy_px1080"), f("drot_graus")
+to, *o = ler(sys.argv[1]); tr, *r = ler(sys.argv[2]); cenas = json.load(open(sys.argv[3])); out = sys.argv[4]
+n = min(len(to), len(tr)); to = to[:n]; o = [x[:n] for x in o]; r = [x[:n] for x in r]
+nomes = ["zoom %/quadro", "dx px/quadro", "dy px/quadro", "giro °/quadro"]
+linhas = ["| cena | zoom corr | dx corr | dy corr | dif. média zoom (%/q) | dif. média trans. (px/q) |", "|---|---|---|---|---|---|"]
+for c in cenas:
+    m = (to >= c["ini"]) & (to < c["fim"])
+    def corr(a, b):
+        ok = m & np.isfinite(a) & np.isfinite(b)
+        return np.corrcoef(a[ok], b[ok])[0, 1] if ok.sum() > 5 and np.std(a[ok]) > 0 and np.std(b[ok]) > 0 else np.nan
+    dz = np.nanmean(abs(o[0][m] - r[0][m])); dt = np.nanmean(np.hypot(o[1][m] - r[1][m], o[2][m] - r[2][m]))
+    linhas.append(f"| {c['id']} | {corr(o[0], r[0]):.2f} | {corr(o[1], r[1]):.2f} | {corr(o[2], r[2]):.2f} | {dz:.2f} | {dt:.1f} |")
+print("\n".join(linhas)); open(out + ".md", "w", encoding="utf-8").write("\n".join(linhas) + "\n")
+for a0, a1 in ((0, 12), (11, 23), (22, 34)):
+    m = (to >= a0) & (to <= a1)
+    fig, ax = plt.subplots(4, 1, figsize=(22, 12), sharex=True)
+    for k in range(4):
+        ax[k].plot(to[m], o[k][m], color="0.2", lw=1.4, label="original"); ax[k].plot(to[m], r[k][m], color="tab:green", lw=1.2, label="recriação")
+        ax[k].set_ylabel(nomes[k]); ax[k].grid(alpha=.3); ax[k].axhline(0, color="k", lw=.5)
+        for c in cenas:
+            if a0 <= c["ini"] <= a1: ax[k].axvline(c["ini"], color="tab:red", alpha=.3)
+    ax[0].legend(loc="upper right"); ax[3].set_xticks(np.arange(a0, a1 + .01, 1))
+    plt.tight_layout(); plt.savefig(f"{out}-{a0:02d}-{a1:02d}.png", dpi=65); plt.close()

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

@@ -0,0 +1,46 @@
+"""Junta a câmera 3D (PLANO) e a mesa 2D de uma cena do jornal num JSON compacto para o gerador do AE.
+Mesa: semelhança medida na madeira (mesa2d-<X>.json) onde existe; antes disso, a câmera 2D medida
+(cena-<id>.json) e, no vão sem madeira à vista, interpolação suave (log zoom, giro, mira).
+Uso: python -I dados_ae_jornal.py F|J  -> ../ae/<id>-dados.json"""
+import json, sys, numpy as np
+C = sys.argv[1]
+ID = {"F": "F-jornal1", "J": "J-jornal2"}[C]
+cam3 = json.load(open(f"camera3d-{C}.json")); mesa = json.load(open(f"mesa2d-{C}.json")); c2 = json.load(open(f"cena-{ID}.json"))["chaves"]
+fs = [q["f"] for q in cam3["quadros"]]
+# --- mesa: semelhança S (tela no ref -> tela no quadro) por quadro
+def par_de_S(S):
+    S = np.array(S); s = float(np.sqrt(abs(np.linalg.det(S[:2, :2])))); th = float(np.degrees(np.arctan2(S[1, 0], S[0, 0])))
+    M = np.linalg.inv(S) @ np.array([540, 540, 1.0]); return [np.log2(s), th, M[0], M[1]]
+def S_de_par(p):
+    s = 2 ** p[0]; th = np.radians(p[1]); R = s * np.array([[np.cos(th), -np.sin(th)], [np.sin(th), np.cos(th)]])
+    S = np.eye(3); S[:2, :2] = R; S[:2, 2] = np.array([540, 540]) - R @ np.array([p[2], p[3]]); return S
+med = {q["f"]: par_de_S(q["S"]) for q in mesa["quadros"] if q["S"] is not None}
+cam2 = {}
+for (t, z), (_, mx), (_, my), (_, g) in zip(c2["zoom"], c2["mx"], c2["my"], c2["giro"]):
+    cam2[int(round(t * 24))] = [z, g, mx, my]
+f_med0 = min(med)                 # primeiro quadro medido na madeira (encadeado a partir do ref)
+CORTE = {"F": 288, "J": 616}[C]   # até aqui vale a câmera 2D (madeira coerente com ela); depois interpola até f_med0
+par = {}
+for f in fs:
+    if f in med: par[f] = med[f]
+    elif f <= CORTE: par[f] = cam2.get(f, cam2[min(cam2, key=lambda k: abs(k - f))])
+for f in fs:
+    if f not in par:
+        a, b = CORTE, f_med0; w = (f - a) / (b - a); w = w * w * (3 - 2 * w)
+        pa, pb = np.array(par[a]), np.array(par[b]); par[f] = list((1 - w) * pa + w * pb)
+# F: nos últimos quadros a borda da mesa aparece; S vem das bordas medidas (encolhe em torno de ~(282,282), sem giro)
+if C == "F":
+    RET = (6, 7, 1059, 1050)
+    bordas = {395: (10, 1048), 396: (15, 1032), 397: (23, 1011), 398: (33, 983)}
+    for f, (L, R) in bordas.items():
+        s = (R - L) / (RET[2] - RET[0]); Tx = L - s * RET[0]; cx = Tx / (1 - s); Ty = (1 - s) * 282
+        S = np.array([[s, 0, Tx], [0, s, Ty], [0, 0, 1.0]]); par[f] = par_de_S(S)
+    pa, pb = np.array(par[397]), np.array(par[398]); par[399] = list(pb + (pb - pa))
+mesa_k = []
+for f in fs:
+    S = S_de_par(par[f]); s = 2 ** par[f][0]
+    mesa_k.append([round(f / 24, 5), [round(x, 5) for x in S[:2].ravel().tolist()]])
+out = {"id": ID, "foco": 1500, "plano": [[q["t"]] + [round(v, 4) for v in q["pos"]] + [round(v, 5) for v in q["rot"]] for q in cam3["quadros"]],
+       "mesa": mesa_k, "encaixe": cam3["encaixe"], "troca": cam3["troca"]}
+json.dump(out, open(f"../ae/{ID}-dados.json", "w"))
+print("ok", ID, len(out["plano"]), "quadros; mesa medida a partir de", f_med0 / 24)

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

@@ -0,0 +1,28 @@
+"""Folha de contato com carimbo de tempo: N quadros por segundo, grade 6×4 por folha.
+Uso: python -P camera/folha_contato.py video.mp4 prefixo_saida QPS [largura_do_quadro]  →  prefixo-01.jpg, -02.jpg…"""
+import sys, os, cv2
+from PIL import Image, ImageDraw, ImageFont
+src, out, fps_s = sys.argv[1], sys.argv[2], float(sys.argv[3])
+w = int(sys.argv[4]) if len(sys.argv)>4 else 270
+cols, rows = 6, 4
+os.makedirs(os.path.dirname(out) or '.', exist_ok=True)
+cap = cv2.VideoCapture(src); fps = cap.get(cv2.CAP_PROP_FPS); n = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
+step = fps / fps_s
+idxs = []; f = 0.0
+while f < n: idxs.append(int(round(f))); f += step
+font = ImageFont.truetype(r"C:\Windows\Fonts\arialbd.ttf", 18)
+frames = []
+for i in idxs:
+    cap.set(cv2.CAP_PROP_POS_FRAMES, i); ok, q = cap.read()
+    if not ok: continue
+    h = int(q.shape[0] * w / q.shape[1]); q = cv2.resize(q, (w, h), interpolation=cv2.INTER_AREA)
+    im = Image.fromarray(cv2.cvtColor(q, cv2.COLOR_BGR2RGB)); d = ImageDraw.Draw(im)
+    lab = f"{i/fps:05.2f}s f{i}"; d.rectangle([0,0,140,22], fill=(0,0,0)); d.text((4,1), lab, fill=(255,255,0), font=font)
+    frames.append(im)
+per = cols*rows
+for s in range(0, len(frames), per):
+    chunk = frames[s:s+per]; W, H = chunk[0].size
+    sheet = Image.new('RGB', (cols*W, rows*H), (40,40,40))
+    for k, im in enumerate(chunk): sheet.paste(im, ((k%cols)*W, (k//cols)*H))
+    sheet.save(f"{out}-{s//per+1:02d}.jpg", quality=85)
+print(len(frames), 'frames', fps, 'fps', n, 'total')

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

@@ -0,0 +1,74 @@
+"""Mede a homografia do plano do jornal quadro a quadro (cenas F-jornal1 e J-jornal2).
+
+O jornal + a mesa formam um plano só. Cada quadro do original é o mesmo plano visto por outra câmera,
+então tela(t) = H(t) · plano. Aqui o "plano" é a tela de um quadro-base em que a página está de frente
+(F: 10,833 s; J: 25,25 s), e H(t) leva a tela do quadro-base para a tela do quadro t.
+
+Método: SIFT + RANSAC (findHomography) entre quadros vizinhos (encadeado) e, sempre que dá, direto contra
+alguns quadros-âncora já medidos (corrige deriva). Saída: camera/homografia-<id>.json {f: [3x3...]}.
+Uso: python -I homografia_jornal.py ORIGINAL F|J
+"""
+import json, sys, cv2, numpy as np
+sys.stdout.reconfigure(encoding="utf-8")
+VID, CENA = sys.argv[1], sys.argv[2]
+if CENA == "F":
+    F0, F1, BASE = 258, 399, 260     # 10,75 s .. 16,625 s ; base 10,833 s
+else:
+    F0, F1, BASE = 589, 673, 591     # 24,54 s .. 28,04 s ; base 24,625 s
+cap = cv2.VideoCapture(VID)
+cap.set(cv2.CAP_PROP_POS_FRAMES, F0)
+Q = {}
+for f in range(F0, F1 + 1):
+    ok, q = cap.read()
+    if not ok: break
+    Q[f] = cv2.cvtColor(q, cv2.COLOR_BGR2GRAY)
+sift = cv2.SIFT_create(nfeatures=6000, contrastThreshold=0.02)
+KP = {f: sift.detectAndCompute(Q[f], None) for f in Q}
+bf = cv2.BFMatcher()
+
+
+def casar(a, b, thr=3.0):
+    """Homografia que leva a tela do quadro a para a tela do quadro b."""
+    k1, d1 = KP[a]; k2, d2 = KP[b]
+    if d1 is None or d2 is None or len(k1) < 12 or len(k2) < 12: 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) < 20: 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])
+    H, inl = cv2.findHomography(p1, p2, cv2.USAC_MAGSAC, thr, maxIters=20000, confidence=0.999)
+    if H is None: return None, 0
+    n = int(inl.sum())
+    if n < 25: return None, n
+    return H / H[2, 2], n
+
+
+# encadeado a partir da base, para frente e para trás; a cada passo tenta casar direto com a base
+# ou com o quadro já medido mais distante que ainda casa bem (menos deriva)
+H = {BASE: np.eye(3)}
+info = {BASE: "base"}
+for direc in (1, -1):
+    f = BASE
+    while F0 <= f + direc <= F1 and (f + direc) in Q:
+        g = f + direc
+        cand = []
+        # vizinho imediato
+        Hn, n = casar(f, g)
+        if Hn is not None: cand.append((n, H[f], Hn, f))
+        # saltos maiores para trás (quadros já medidos) para segurar a deriva
+        for salto in (3, 6, 12, 24):
+            h = g - direc * salto
+            if h in H and h != f:
+                Hj, nj = casar(h, g)
+                if Hj is not None and nj > 60: cand.append((nj * 1.15, H[h], Hj, h))
+        if not cand:
+            print("sem casamento em", g); H[g] = H[f]; info[g] = "repetido"; f = g; continue
+        cand.sort(key=lambda c: -c[0])
+        n, Hb, Hj, h = cand[0]
+        H[g] = Hj @ Hb; H[g] /= H[g][2, 2]; info[g] = f"de {h} ({int(n)} pts)"
+        f = g
+out = {str(f): H[f].tolist() for f in sorted(H)}
+json.dump({"base": BASE, "fps": 24, "H": out, "info": {str(k): v for k, v in info.items()}},
+          open(f"homografia-{CENA}.json", "w"), indent=0)
+for f in sorted(H):
+    c = H[f] @ np.array([540, 540, 1.0]); c /= c[2]
+    print(f, f"{f/24:7.3f}", info[f], np.round(c[:2], 1))

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

@@ -0,0 +1,44 @@
+"""Integra o movimento global medido quadro a quadro (05-quadro-a-quadro.csv) em câmera absoluta por cena.
+
+Mundo da cena N = tela do original no instante de referência r_N (câmera identidade em r_N).
+Saída por quadro: zoom s, giro θ (graus), ponto de mira w (coordenadas do mundo, px de 1080),
+e a pegada da tela no mundo (para saber até onde a interface precisa existir).
+"""
+import csv, json, sys, numpy as np
+
+CSV = sys.argv[1]; CENAS = json.load(open(sys.argv[2], encoding="utf-8")); SAIDA = sys.argv[3]
+R = list(csv.DictReader(open(CSV)))
+FPS = 24.0
+c = np.array([540.0, 540.0])
+
+def M_quadro(i):
+    """Transformação da tela do quadro i-1 para a do quadro i (similaridade em torno do centro)."""
+    r = R[i - 1]  # linha i-1 do csv descreve quadro i (o csv começa no quadro 1)
+    try:
+        ds, dr, dx, dy = float(r["descala"]), np.radians(float(r["drot_graus"])), float(r["dx_px1080"]), float(r["dy_px1080"])
+        if not np.isfinite(ds): raise ValueError
+    except ValueError:
+        ds, dr, dx, dy = 1.0, 0.0, 0.0, 0.0
+    A = ds * np.array([[np.cos(dr), -np.sin(dr)], [np.sin(dr), np.cos(dr)]])
+    t = c + np.array([dx, dy]) - A @ c
+    M = np.eye(3); M[:2, :2] = A; M[:2, 2] = t
+    return M
+
+out = {}
+for cena in CENAS:
+    nome, ini, fim, ref = cena["id"], cena["ini"], cena["fim"], cena["ref"]
+    fi, ff, fr = int(round(ini * FPS)), int(round(fim * FPS)), int(round(ref * FPS))
+    S = {fr: np.eye(3)}
+    for f in range(fr + 1, ff + 1): S[f] = M_quadro(f) @ S[f - 1]
+    for f in range(fr - 1, fi - 1, -1): S[f] = np.linalg.inv(M_quadro(f + 1)) @ S[f + 1]
+    linhas = []; xs = []; ys = []
+    for f in range(fi, ff + 1):
+        A = S[f][:2, :2]; s = float(np.sqrt(abs(np.linalg.det(A)))); th = float(np.degrees(np.arctan2(A[1, 0], A[0, 0])))
+        Si = np.linalg.inv(S[f]); w = (Si @ np.array([540, 540, 1.0]))[:2]
+        cant = [(Si @ np.array([x, y, 1.0]))[:2] for x, y in ((0, 0), (1080, 0), (1080, 1080), (0, 1080))]
+        xs += [p[0] for p in cant]; ys += [p[1] for p in cant]
+        linhas.append({"f": f, "t": round(f / FPS, 4), "s": round(s, 5), "rot": round(th, 3), "wx": round(float(w[0]), 2), "wy": round(float(w[1]), 2)})
+    out[nome] = {"ini": ini, "fim": fim, "ref": ref, "pegada": [round(min(xs)), round(min(ys)), round(max(xs)), round(max(ys))], "quadros": linhas}
+    s = [l["s"] for l in linhas]
+    print(f"{nome}: {ini:5.2f}-{fim:5.2f} ref {ref:5.2f} | zoom {s[0]:.2f} -> {s[-1]:.2f} (min {min(s):.2f} max {max(s):.2f}) | pegada x[{min(xs):.0f},{max(xs):.0f}] y[{min(ys):.0f},{max(ys):.0f}]")
+json.dump(out, open(SAIDA, "w"), indent=0)

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

@@ -0,0 +1,32 @@
+import sys, csv, importlib.util, numpy as np
+spec = importlib.util.spec_from_file_location("olho", r"<SUA_CENTRAL>\07-videos\scripts\olho_quadro_a_quadro.py")
+olho = importlib.util.module_from_spec(spec); spec.loader.exec_module(olho)
+import cv2
+from PIL import Image, ImageDraw
+video, saida = sys.argv[1], sys.argv[2]
+larg = 540
+q, t, fps = olho.ler_quadros(video, 0, None, None, larg)
+k = 1080 / larg
+rows = []
+g0 = cv2.cvtColor(q[0], cv2.COLOR_BGR2GRAY); h, w = g0.shape; c = np.array([w/2, h/2, 1.0])
+for i in range(1, len(q)):
+    g1 = cv2.cvtColor(q[i], cv2.COLOR_BGR2GRAY)
+    p0 = cv2.goodFeaturesToTrack(g0, 600, 0.01, 6)
+    M = None; inl = 0; npts = 0
+    if p0 is not None and len(p0) >= 6:
+        p1, st, _ = cv2.calcOpticalFlowPyrLK(g0, g1, p0, None, winSize=(25, 25), maxLevel=4)
+        b = st.ravel() == 1; npts = int(b.sum())
+        if npts >= 6:
+            M, m = cv2.estimateAffinePartial2D(p0[b], p1[b], method=cv2.RANSAC, ransacReprojThreshold=2.0)
+            inl = int(m.sum()) if m is not None else 0
+    diff = float(np.abs(g1.astype(np.float32) - g0.astype(np.float32)).mean())
+    if M is None:
+        rows.append([t[i], i, np.nan, np.nan, np.nan, np.nan, npts, inl, diff])
+    else:
+        d = M @ c - c[:2]
+        rows.append([t[i], i, d[0]*k, d[1]*k, np.degrees(np.arctan2(M[1,0], M[0,0])), float(np.hypot(M[0,0], M[1,0])), npts, inl, diff])
+    g0 = g1
+with open(saida + ".csv", "w", newline="") as fh:
+    wr = csv.writer(fh); wr.writerow(["t","quadro","dx_px1080","dy_px1080","drot_graus","descala","pontos","inliers","dif_media"])
+    for r in rows: wr.writerow([round(float(v),4) if isinstance(v,(float,np.floating)) else v for v in r])
+print(len(rows), "quadros", fps)