import json import random import pytest from app.reaction import ( FaceSample, FaceSecond, ReactionParams, label, locate_cam, per_second, reaction_moments, reaction_signal, seconds_from_json, seconds_to_json, summarize, ) FPS = 6 def neutral_blend(rng: random.Random, smile: float = 0.05) -> dict[str, float]: """Rosto parado: blendshapes baixos com ruído (fala/tique), sorriso no nível pedido.""" n = lambda base: max(0.0, min(1.0, base + rng.uniform(-0.03, 0.03))) # noqa: E731 return { "mouthSmileLeft": n(smile), "mouthSmileRight": n(smile), "jawOpen": n(0.08), "eyeWideLeft": n(0.05), "eyeWideRight": n(0.05), "browInnerUp": n(0.05), "browOuterUpLeft": n(0.04), "browOuterUpRight": n(0.04), "browDownLeft": n(0.05), "browDownRight": n(0.05), "eyeBlinkLeft": n(0.1), "eyeBlinkRight": n(0.1), } def track(duration: int, seed: int = 1, smile: float = 0.05, events: dict | None = None, absent: range | None = None) -> list[FaceSample]: """Quadros a 6 qps. `events`: {segundo: função(blend, rng) → (blend, dx, dy)} para injetar reações.""" rng = random.Random(seed) events = events or {} out = [] for i in range(duration * FPS): t = i / FPS if absent is not None and int(t) in absent: out.append(FaceSample(t, False)) continue blend, dx, dy = neutral_blend(rng, smile), 0.0, 0.0 if int(t) in events: blend, dx, dy = events[int(t)](blend, rng) cx = 0.5 + rng.uniform(-0.005, 0.005) + dx cy = 0.4 + rng.uniform(-0.005, 0.005) + dy out.append(FaceSample(t, True, cx, cy, 0.3, blend)) return out def laugh(blend, rng): blend |= {"mouthSmileLeft": 0.9, "mouthSmileRight": 0.85, "jawOpen": 0.7} return blend, 0.0, rng.uniform(-0.02, 0.02) def scream(blend, rng): blend |= {"mouthSmileLeft": 0.02, "mouthSmileRight": 0.02, "jawOpen": 0.85} return blend, 0.0, 0.0 def startle(blend, rng): blend |= {"eyeWideLeft": 0.8, "eyeWideRight": 0.8, "browInnerUp": 0.7, "browOuterUpLeft": 0.6, "browOuterUpRight": 0.6} return blend, rng.choice([-1, 1]) * 0.1, rng.uniform(-0.08, 0.08) # --- série e sinal ------------------------------------------------------------------------------------------------ def test_per_second_shapes_and_none_without_face(): seconds = per_second(track(10, absent=range(4, 6)), 10) assert [s.t for s in seconds] == list(range(10)) assert seconds[0].present == 1.0 and 0.0 <= seconds[0].smile <= 0.1 and seconds[0].size == 0.3 assert seconds[4].present == 0.0 and seconds[4].smile is None and seconds[4].cx is None assert seconds[0].motion is not None and seconds[0].motion < 0.5 def test_json_roundtrip_is_compact_and_rounded(): seconds = per_second(track(5, absent=range(2, 3)), 5) data = seconds_to_json(seconds) assert "smile" not in data[2] and data[2]["present"] == 0.0 assert all(len(str(v).split(".")[-1]) <= 3 for d in data for v in d.values() if isinstance(v, float)) back = seconds_from_json(json.loads(json.dumps(data))) assert back[2].smile is None and abs(back[0].cx - seconds[0].cx) < 1e-3 def test_neutral_with_noise_has_no_peak(): seconds = per_second(track(300, seed=3), 300) assert reaction_moments(seconds) == [] signal = reaction_signal(seconds) assert max(v for v in signal if v is not None) < ReactionParams().threshold def test_laugh_is_a_peak_with_right_label_and_onset(): events = {t: laugh for t in range(200, 205)} seconds = per_second(track(300, events=events), 300) moments = reaction_moments(seconds) assert len(moments) == 1 m = moments[0] assert m.label == "risada" and 200 <= m.peak_s <= 204 assert m.onset_s == 200 # a reação começa exatamente onde o evento começou assert m.end_s >= 204 and m.strong def test_constant_smiling_streamer_is_not_a_false_positive(): # Streamer de "neutro sorridente": o sorriso alto é o normal dele, não reação. seconds = per_second(track(300, seed=5, smile=0.65), 300) assert reaction_moments(seconds) == [] # E uma risada de verdade nesse mesmo streamer ainda aparece (pela boca). events = {t: (lambda b, r: (b | {"jawOpen": 0.7, "mouthSmileLeft": 0.8, "mouthSmileRight": 0.8}, 0.0, 0.0)) for t in range(150, 154)} moments = reaction_moments(per_second(track(300, seed=5, smile=0.65, events=events), 300)) assert [m.label for m in moments] == ["risada"] def test_scream_versus_laugh(): events = {t: scream for t in range(100, 103)} | {t: laugh for t in range(200, 203)} moments = reaction_moments(per_second(track(300, events=events), 300)) assert [(m.label, 100 <= m.peak_s <= 102 or 200 <= m.peak_s <= 202) for m in moments] == [ ("grito", True), ("risada", True)] def test_startle_versus_shock(): still = lambda b, r: (startle(b, r)[0], 0.0, 0.0) # noqa: E731 — olhos/sobrancelha sem pulo da cabeça events = {t: startle for t in range(100, 102)} | {t: still for t in range(200, 202)} labels = [m.label for m in reaction_moments(per_second(track(300, events=events), 300))] assert labels == ["susto", "choque"] def test_seconds_without_face_are_none_and_never_peak(): # Rosto some exatamente na hora em que haveria uma "risada": não pode virar pico. events = {t: laugh for t in range(150, 155)} seconds = per_second(track(300, events=events, absent=range(148, 158)), 300) signal = reaction_signal(seconds) assert all(signal[t] is None for t in range(148, 158)) assert reaction_moments(seconds) == [] def test_label_without_z_uses_absolute_thresholds(): s = FaceSecond(0, 1.0, 0.5, 0.4, 0.3, smile=0.8, jaw=0.7, surprise=0.1, frown=0.0, blink=0.1, motion=0.1) assert label(s) == "risada" s.smile = 0.0 assert label(s) == "grito" assert label(FaceSecond(1, 0.0)) == "neutro" assert label(FaceSecond(2, 1.0, smile=0.0, jaw=0.0, surprise=0.0, frown=0.6, motion=0.0)) == "raiva" def test_summarize_text_for_the_judge(): events = {t: laugh for t in range(200, 204)} | {t: startle for t in range(215, 217)} seconds = per_second(track(300, events=events), 300) text = summarize(seconds, 190, 230) assert text.startswith("risada forte em 1") and "susto" in text and "; " in text assert summarize(seconds, 20, 60) == "sem reação marcante no rosto" gone = per_second(track(100, absent=range(0, 100)), 100) assert summarize(gone, 0, 50) == "rosto do streamer não aparece no trecho" # --- câmera ------------------------------------------------------------------------------------------------------- W, H = 1920, 1080 def cam_face(rng: random.Random) -> tuple[float, float, float, float, float]: """Rosto da câmera no canto inferior esquerdo, com tremida de poucos pixels.""" return (120 + rng.uniform(-4, 4), 700 + rng.uniform(-4, 4), 110, 130, 0.9) def inside_unit(rect: dict) -> bool: return (0 <= rect["x"] <= 1 and 0 <= rect["y"] <= 1 and rect["w"] > 0 and rect["h"] > 0 and rect["x"] + rect["w"] <= 1 + 1e-9 and rect["y"] + rect["h"] <= 1 + 1e-9) def test_locate_cam_stable_corner(): rng = random.Random(1) frames = [[cam_face(rng)] for _ in range(12)] result = locate_cam(frames, W, H) assert result["hasWebcam"] and not result["fullFrame"] and result["confidence"] > 0.7 cam, face = result["cam"], result["faceRect"] assert inside_unit(cam) and inside_unit(face) # O rosto fica dentro do retângulo da câmera, que está no canto inferior esquerdo. assert cam["x"] <= face["x"] and cam["y"] <= face["y"] assert face["x"] + face["w"] <= cam["x"] + cam["w"] and face["y"] + face["h"] <= cam["y"] + cam["h"] assert cam["x"] < 0.1 and cam["y"] > 0.4 and cam["w"] < 0.3 def test_locate_cam_ignores_cutscene_face(): rng = random.Random(2) frames = [[cam_face(rng)] for _ in range(12)] frames[3].append((900, 300, 200, 240, 0.95)) # rosto do personagem na cutscene, só em 2 de 12 quadros frames[4].append((905, 302, 198, 238, 0.95)) result = locate_cam(frames, W, H) assert result["hasWebcam"] and result["faceRect"]["x"] < 0.1 # Só a cutscene (sem câmera): nada. only = [[] for _ in range(12)] only[3], only[4] = [(900, 300, 200, 240, 0.95)], [(905, 302, 198, 238, 0.95)] assert locate_cam(only, W, H)["hasWebcam"] is False def test_locate_cam_full_frame(): rng = random.Random(3) frames = [[(760 + rng.uniform(-10, 10), 250, 420, 520, 0.95)] for _ in range(10)] result = locate_cam(frames, W, H) assert result["hasWebcam"] and result["fullFrame"] and result["cam"] == {"x": 0, "y": 0, "w": 1, "h": 1} def test_locate_cam_no_face(): result = locate_cam([[] for _ in range(12)], W, H) assert result == {"hasWebcam": False, "cam": None, "faceRect": None, "confidence": 0.0, "fullFrame": False} assert locate_cam([], W, H)["hasWebcam"] is False # Detecções fracas (score baixo) não contam. assert locate_cam([[(120, 700, 110, 130, 0.3)] for _ in range(12)], W, H)["hasWebcam"] is False def test_locate_cam_rect_clipped_and_snapped_to_frame_edges(): # Rosto colado no canto: a expansão passaria da borda do quadro e precisa ser recortada em 0..1. frames = [[(10, 950, 110, 120, 0.9)] for _ in range(8)] result = locate_cam(frames, W, H) assert inside_unit(result["cam"]) and result["cam"]["x"] == 0 # Com bordas persistentes da moldura, o retângulo encaixa nelas. rng = random.Random(4) frames = [[cam_face(rng)] for _ in range(12)] edges = {"xs": [0.02, 0.2, 0.7], "ys": [0.55, 0.95, 0.1]} cam = locate_cam(frames, W, H, edges=edges)["cam"] assert cam == {"x": 0.02, "y": 0.55, "w": 0.18, "h": 0.4} # --- ajustes da bancada (números reais da sessão 3, doc/FACE_BAKEOFF.md) ------------------------------------------ def real_calm(n: int, seed: int = 7) -> list[FaceSecond]: """Neutro como o da live real: sorriso por segundo 0,02–0,25 (mediana ~0,1), boca ~0, olho arregalado ~0.""" rng = random.Random(seed) return [FaceSecond(t, 1.0, 0.5, 0.4, 0.3, smile=rng.uniform(0.02, 0.22), jaw=rng.uniform(0.0, 0.01), surprise=rng.uniform(0.0, 0.004), frown=rng.uniform(0.01, 0.07), brow=rng.uniform(0.01, 0.05), blink=0.1, motion=rng.uniform(0.02, 0.15)) for t in range(n)] def test_real_calm_with_isolated_spikes_has_no_peak(): # No calmo real houve um segundo com sorriso 0,38 e outro com browInnerUp 0,38: não é reação. seconds = real_calm(300) seconds[200].smile = 0.38 seconds[250].brow = 0.38 assert reaction_moments(seconds) == [] def test_laugh_without_open_mouth_is_risada(): # Corte 10/12: sorriso 0,84–0,95 por vários segundos com jawOpen ≤ 0,11. seconds = real_calm(300) for t in range(200, 210): seconds[t].smile, seconds[t].jaw = 0.9, 0.05 moments = reaction_moments(seconds) assert [m.label for m in moments] == ["risada"] and moments[0].onset_s == 200 and moments[0].strong def test_shout_is_jaw_and_brow_down_without_smile(): # Corte 10, 1628 s: jawOpen 0,42 + browDown forte, sorriso 0,06 naquele segundo. seconds = real_calm(300) seconds[200].smile, seconds[200].jaw, seconds[200].frown = 0.06, 0.42, 0.5 seconds[250].frown = 0.6 # franziu de boca fechada labels = [(m.peak_s, m.label) for m in reaction_moments(seconds)] assert labels == [(200, "grito"), (250, "raiva")] def test_confused_brow_inner_up_without_smile(): # Corte 9 (lag): browInnerUp 0,7–0,8 por ~6 s, sorriso baixo, eyeWide ~0. seconds = real_calm(300) for t in range(200, 206): seconds[t].brow = 0.78 moments = reaction_moments(seconds) assert [m.label for m in moments] == ["confuso"] and moments[0].onset_s == 200 def test_surprise_does_not_need_eye_wide(): # Na live real eyeWide fica ~0: sobrancelha (interna OU externa) levantada é o canal `brow`; parada = confuso, # com a cabeça se mexendo = susto. Olho arregalado parado continua sendo choque. blend = {"browOuterUpLeft": 0.7, "browOuterUpRight": 0.7, "eyeWideLeft": 0.0, "eyeWideRight": 0.0} second = per_second([FaceSample(0.1, True, 0.5, 0.4, 0.3, blend)], 1)[0] assert second.brow == pytest.approx(0.7) and second.surprise == 0.0 assert label(second) == "confuso" second.motion = 0.9 assert label(second) == "susto" eyes = per_second([FaceSample(0.1, True, 0.5, 0.4, 0.3, {"eyeWideLeft": 0.8, "eyeWideRight": 0.8})], 1)[0] assert label(eyes) == "choque" def test_motion_alone_or_with_flickering_face_is_not_a_peak(): # Rastreio pulando (rosto em 1/3 do segundo) dava "susto" de intensidade 13 na live real. seconds = real_calm(300) seconds[200].present, seconds[200].motion, seconds[200].brow = 0.33, 3.0, 0.2 seconds[250].motion = 3.0 # só movimento, rosto inteiro: ajeitou a cadeira assert reaction_moments(seconds) == [] def test_old_series_without_brow_still_works(): # Série gravada antes do canal `brow`: o canal fica parado, sem quebrar. data = seconds_to_json(real_calm(60)) for d in data: d.pop("brow", None) assert all(v is not None for v in reaction_signal(seconds_from_json(data))) def test_summarize_absolute_times_for_the_prompt(): seconds = real_calm(300) for t in range(200, 205): seconds[t].smile = 0.9 assert summarize(seconds, 190, 230, relative=False).startswith("risada forte em 20") def test_locate_cam_leaning_streamer_stays_one_group(): # Câmera grande (rosto ~0,16 do quadro): ele se inclina 0,8 largura de rosto em metade dos quadros. # Com distância fixa em fração do quadro (ou comparando com o 1º membro) o grupo se partia em dois. rng = random.Random(9) frames = [] for i in range(12): lean = 0.8 * 300 if i % 2 else 0 frames.append([(200 + lean + rng.uniform(-4, 4), 600 + rng.uniform(-4, 4), 300, 340, 0.9)]) result = locate_cam(frames, W, H) assert result["hasWebcam"] and result["confidence"] > 0.5 # partido em dois daria presença 0,5 → ≤ 0,45 face = result["faceRect"] center = (face["x"] + face["w"] / 2) * W assert 200 + 150 + 80 < center < 200 + 150 + 160 # média das duas posições (~350 + 120) def test_locate_cam_frameless_keeps_forehead(): # Câmera sem moldura (streamer recortado sobre o jogo, banner logo abaixo): o retângulo vem do rosto e deixa # folga acima da testa — a IA cortava a testa (topo em y 0,532 com o rosto começando em 0,504). fw, fh = 1280, 720 frames = [[(80 + i % 3, 363, 85, 109, 0.92)] for i in range(12)] # rosto da bancada: x 0,066 y 0,504 h 0,152 result = locate_cam(frames, fw, fh) cam, face = result["cam"], result["faceRect"] assert face["y"] - cam["y"] >= 0.5 * face["h"] # testa e cabelo dentro assert cam["y"] + cam["h"] >= face["y"] + face["h"] + face["h"] # ombros/peito abaixo do queixo # Borda "falsa" logo acima da testa (ex.: banner) não corta a cabeça. edges = {"xs": [], "ys": [face["y"] - 0.01]} assert locate_cam(frames, fw, fh, edges=edges)["cam"]["y"] < face["y"] - 0.3 * face["h"] def test_two_hours_of_series_is_fast(): # channel_z era O(n²): a API e a pontuação recalculam a live inteira. 2 h sintéticas precisam de < 1 s. import time seconds = real_calm(7200, seed=3) for t in range(4000, 4006): seconds[t].smile = 0.9 started = time.perf_counter() moments = reaction_moments(seconds) assert time.perf_counter() - started < 1.0 assert [m.label for m in moments] == ["risada"] and moments[0].onset_s == 4000 def test_locate_cam_ignores_static_low_score_object(): """Teste ao vivo de 17/11 (lofigirl, sem webcam): a tela de um notebook desenhado na borda esquerda saiu como rosto de 24×34 px com score 0,61–0,66 em 8 de 12 quadros e virou câmera. Webcam real: 0,92–0,94.""" fake = (0.0, 415.0, 24.0, 34.0, 0.63) frames = [[fake], [fake], [fake, (726.0, 253.0, 73.0, 98.0, 0.604)], [], [fake], [], [fake], [fake], [(606.0, 254.0, 155.0, 197.0, 0.615)], [fake], [], [fake, (605.0, 257.0, 154.0, 193.0, 0.61)]] assert locate_cam(frames, 1280, 720)["hasWebcam"] is False real = [[(109.0 + i % 3, 359.0, 82.0, 112.0, 0.93)] for i in range(12)] assert locate_cam(real, 1280, 720)["hasWebcam"] is True